Intermediate files exportation now handle atlas information

Author: Louis Fréneau

src/lib/bitstreamGeneration/atlas_context.cpp

@@ -65,7 +65,7 @@ class atlas_context {
     atlas_frame_parameter_set& get_afps() { return afps_; };
 
     // -------------- Getters - helper variables --------------
-    size_t get_gof_id() { return gof_id_; };
+    size_t get_gof_id() const { return gof_id_; };
     size_t get_atlas_sub_size() { return atlas_sub_size_; };
     std::vector<size_t> get_ad_nal_sizes() { return ad_nal_sizes_; };
     size_t get_ad_nal_precision() { return ad_nal_precision_; };

src/lib/bitstreamGeneration/atlas_context.hpp

@@ -39,6 +39,10 @@
 #include <cstring>
 #include <new>
 
+#include "utils/parameters.hpp"
+#include "utils/fileExport.hpp"
+
+
 // NOLINTBEGIN(cppcoreguidelines-owning-memory,cppcoreguidelines-no-malloc,hicpp-no-malloc) //
 // TODO(gg) : lf : Currently we manually handle most of the memory object in the bitstream generation. Consider reducing alloc use to minimum
 
@@ -173,6 +177,28 @@ void uvg_bitstream_put_ue(bitstream_t *stream, uint32_t code_num) {
     uvg_bitstream_put(stream, value, num_bits);
 }
 
+void writeU(bitstream_t *const stream, const uint32_t data, uint8_t bits, std::string name, size_t gofId) {
+    uvg_bitstream_put(stream, data, bits);
+    if(uvgvpcc_enc::p_->exportIntermediateFiles) {
+        std::ostringstream oss;
+        oss << std::left << std::setw(50) << name
+            << " u(" << bits << ") : " << data;
+        std::string logLine = oss.str();
+        FileExport::exportAtlasInformation(gofId,logLine);
+    }
+}
+
+void writeUE(bitstream_t *const stream, const uint32_t data, std::string name, size_t gofId) {
+    uvg_bitstream_put_ue(stream, data);
+    if(uvgvpcc_enc::p_->exportIntermediateFiles) {
+        std::ostringstream oss;
+        oss << std::left << std::setw(50) << name
+        << " ue(v): " << data;
+        std::string logLine = oss.str();
+        FileExport::exportAtlasInformation(gofId,logLine);
+    }
+}
+
 // TODO(lf): rename this function
 size_t uvg_calculate_ue_len(uint32_t number) {
     const unsigned code_num_log2 = uvg_math_floor_log2(number + 1);

src/lib/bitstreamGeneration/bitstream_util.cpp

@@ -35,8 +35,9 @@
 #include <cassert>
 #include <cstring>
 #include <cstdint>
+#include <string>
 
-#define BITSTREAM_DEBUG false
+#define BITSTREAM_DEBUG true
 
 /* Size of data chunks */
 #define UVG_DATA_CHUNK_SIZE 4096
@@ -124,26 +125,29 @@ void uvg_bitstream_copy_bytes(bitstream_t *const stream, const uint8_t *bytes, u
 /* Get the last (possibly incomplete) byte of the bitstream */
 uint32_t uvg_bitstream_peek_last_byte(bitstream_t *const stream);
 
-/* In debug mode print out some extra info */
-#if BITSTREAM_DEBUG
+/* In debug mode print out some extra info */ // lf: replaced with file export function
+// #if BITSTREAM_DEBUG
 /* Counter to keep up with bits written */
-#define WRITE_U(stream, data, bits, name)               \
-    {                                                   \
-        printf("%-50s u(%d) : %d\n", name, bits, data); \
-        uvg_bitstream_put(stream, data, bits);          \
-    }
-#define WRITE_UE(stream, data, name)             \
-    {                                            \
-        printf("%-50s ue(v): %d\n", name, data); \
-        uvg_bitstream_put_ue(stream, data);      \
-    }
-#else
-#define WRITE_U(stream, data, bits, name)      \
-    {                                          \
-        uvg_bitstream_put(stream, data, bits); \
-    }
-#define WRITE_UE(stream, data, name)        \
-    {                                       \
-        uvg_bitstream_put_ue(stream, data); \
-    }
-#endif
+// #define WRITE_U(stream, data, bits, name)               \
+//     {                                                   \
+//         printf("%-50s u(%d) : %d\n", name, bits, data); \
+//         uvg_bitstream_put(stream, data, bits);          \
+//     }
+// #define WRITE_UE(stream, data, name)             \
+//     {                                            \
+//         printf("%-50s ue(v): %d\n", name, data); \
+//         uvg_bitstream_put_ue(stream, data);      \
+//     }
+// #else
+// #define WRITE_U(stream, data, bits, name)      \
+//     {                                          \
+//         uvg_bitstream_put(stream, data, bits); \
+//     }
+// #define WRITE_UE(stream, data, name)        \
+//     {                                       \
+//         uvg_bitstream_put_ue(stream, data); \
+//     }
+// #endif
+
+void writeU(bitstream_t *const stream, const uint32_t data, uint8_t bits, std::string name, size_t gofId);
+void writeUE(bitstream_t *const stream, const uint32_t data, std::string name, size_t gofId);

src/lib/bitstreamGeneration/bitstream_util.hpp

@@ -54,7 +54,8 @@ vps::vps(const uvgvpcc_enc::Parameters& paramUVG, const std::shared_ptr<uvgvpcc_
             "Error : unknown ptl_profile_codec_group_idc. This bitstream parameter indicates what codec is used to encode the 2D videos.");
     }
     size_t vps_length_bits = 0;
-    ptl_ = fill_ptl(vps_length_bits);                // profile_tier_level
+    ptl_ = fill_ptl(vps_length_bits);          // profile_tier_level
+    gofId = gofUVG->gofId;                           // lf addition for exporting intermediate atlas information
     vps_v3c_parameter_set_id_ = gofUVG->gofId % 16;  // The value of vps_v3c_parameter_set_id shall be in the range of 0 to 15
     vps_atlas_count_minus1_ = 0;                     // for atlas count 1
     vps_length_bits += 18;                           // fixed fields
@@ -152,85 +153,86 @@ vps::vps(const uvgvpcc_enc::Parameters& paramUVG, const std::shared_ptr<uvgvpcc_
 }
 
 bool vps::write_vps(bitstream_t* stream) {
+    
     // profile_tier_level
-    WRITE_U(stream, ptl_.ptl_tier_flag, 1, "ptl_tier_flag");
-    WRITE_U(stream, ptl_.ptl_profile_codec_group_idc, 7, "ptl_profile_codec_group_idc");
-    WRITE_U(stream, ptl_.ptl_profile_toolset_idc, 8, "ptl_profile_toolset_idc");
-    WRITE_U(stream, ptl_.ptl_profile_reconstruction_idc, 8, "ptl_profile_reconstruction_idc");
-    WRITE_U(stream, 0, 16, "ptl_reserved_zero_16bits");
-    WRITE_U(stream, ptl_.ptl_max_decodes_idc, 4, "ptl_max_decodes_idc");
-    WRITE_U(stream, 0xfff, 12, "ptl_reserved_0xfff_12bits");
-    WRITE_U(stream, ptl_.ptl_level_idc, 8, "ptl_level_idc");
-    WRITE_U(stream, ptl_.ptl_num_sub_profiles, 6, "ptl_num_sub_profiles");
-    WRITE_U(stream, ptl_.ptl_extended_sub_profile_flag, 1, "ptl_extended_sub_profile_flag");
-    WRITE_U(stream, ptl_.ptl_toolset_constraints_present_flag, 1, "ptl_toolset_constraints_present_flag");
+    writeU(stream, ptl_.ptl_tier_flag, 1, "ptl_tier_flag",gofId);
+    writeU(stream, ptl_.ptl_profile_codec_group_idc, 7, "ptl_profile_codec_group_idc",gofId);
+    writeU(stream, ptl_.ptl_profile_toolset_idc, 8, "ptl_profile_toolset_idc",gofId);
+    writeU(stream, ptl_.ptl_profile_reconstruction_idc, 8, "ptl_profile_reconstruction_idc",gofId);
+    writeU(stream, 0, 16, "ptl_reserved_zero_16bits",gofId);
+    writeU(stream, ptl_.ptl_max_decodes_idc, 4, "ptl_max_decodes_idc",gofId);
+    writeU(stream, 0xfff, 12, "ptl_reserved_0xfff_12bits",gofId);
+    writeU(stream, ptl_.ptl_level_idc, 8, "ptl_level_idc",gofId);
+    writeU(stream, ptl_.ptl_num_sub_profiles, 6, "ptl_num_sub_profiles",gofId);
+    writeU(stream, ptl_.ptl_extended_sub_profile_flag, 1, "ptl_extended_sub_profile_flag",gofId);
+    writeU(stream, ptl_.ptl_toolset_constraints_present_flag, 1, "ptl_toolset_constraints_present_flag",gofId);
 
     // profile_toolset_constraints_information
     // TODO(lf): Do we need profile_toolset_constraints_information? Not present from TMC2 interface
 
-    WRITE_U(stream, vps_v3c_parameter_set_id_, 4, "vps_v3c_parameter_set_id");
-    WRITE_U(stream, 0, 8, "vps_reserved_zero_8bits");
-    WRITE_U(stream, vps_atlas_count_minus1_, 6, "vps_atlas_count_minus1");
+    writeU(stream, vps_v3c_parameter_set_id_, 4, "vps_v3c_parameter_set_id",gofId);
+    writeU(stream, 0, 8, "vps_reserved_zero_8bits",gofId);
+    writeU(stream, vps_atlas_count_minus1_, 6, "vps_atlas_count_minus1",gofId);
 
     for (uint8_t j = 0; j < (vps_atlas_count_minus1_ + 1); j++) {
-        WRITE_U(stream, j, 6, "vps_atlas_id");
-        WRITE_UE(stream, int(vps_frame_width_.at(j)), "vps_frame_width");
-        WRITE_UE(stream, int(vps_frame_height_.at(j)), "vps_frame_height");
-        WRITE_U(stream, vps_map_count_minus1_.at(j), 4, "vps_map_count_minus1");
+        writeU(stream, j, 6, "vps_atlas_id",gofId);
+        writeUE(stream, int(vps_frame_width_.at(j)), "vps_frame_width",gofId);
+        writeUE(stream, int(vps_frame_height_.at(j)), "vps_frame_height",gofId);
+        writeU(stream, vps_map_count_minus1_.at(j), 4, "vps_map_count_minus1",gofId);
 
         if (vps_map_count_minus1_.at(j) > 0) {
-            WRITE_U(stream, int(vps_multiple_map_streams_present_flag_.at(j)), 1, "vps_multiple_map_streams_present_flag");
+            writeU(stream, int(vps_multiple_map_streams_present_flag_.at(j)), 1, "vps_multiple_map_streams_present_flag",gofId);
         }
-        WRITE_U(stream, int(vps_auxiliary_video_present_flag_.at(j)), 1, "vps_auxiliary_video_present_flag");
-        WRITE_U(stream, int(vps_occupancy_video_present_flag_.at(j)), 1, "vps_occupancy_video_present_flag");
-        WRITE_U(stream, int(vps_geometry_video_present_flag_.at(j)), 1, "vps_geometry_video_present_flag");
-        WRITE_U(stream, int(vps_attribute_video_present_flag_.at(j)), 1, "vps_attribute_video_present_flag");
+        writeU(stream, int(vps_auxiliary_video_present_flag_.at(j)), 1, "vps_auxiliary_video_present_flag",gofId);
+        writeU(stream, int(vps_occupancy_video_present_flag_.at(j)), 1, "vps_occupancy_video_present_flag",gofId);
+        writeU(stream, int(vps_geometry_video_present_flag_.at(j)), 1, "vps_geometry_video_present_flag",gofId);
+        writeU(stream, int(vps_attribute_video_present_flag_.at(j)), 1, "vps_attribute_video_present_flag",gofId);
 
         if (vps_occupancy_video_present_flag_.at(j)) {
-            WRITE_U(stream, occupancy_info_.at(j).oi_occupancy_codec_id, 8, "oi_occupancy_codec_id");
-            WRITE_U(stream, occupancy_info_.at(j).oi_lossy_occupancy_compression_threshold, 8, "oi_lossy_occupancy_compression_threshold");
-            WRITE_U(stream, occupancy_info_.at(j).oi_occupancy_2d_bit_depth_minus1, 5, "oi_occupancy_2d_bit_depth_minus1");
-            WRITE_U(stream, occupancy_info_.at(j).oi_occupancy_MSB_align_flag, 1, "oi_occupancy_MSB_align_flag");
+            writeU(stream, occupancy_info_.at(j).oi_occupancy_codec_id, 8, "oi_occupancy_codec_id",gofId);
+            writeU(stream, occupancy_info_.at(j).oi_lossy_occupancy_compression_threshold, 8, "oi_lossy_occupancy_compression_threshold",gofId);
+            writeU(stream, occupancy_info_.at(j).oi_occupancy_2d_bit_depth_minus1, 5, "oi_occupancy_2d_bit_depth_minus1",gofId);
+            writeU(stream, occupancy_info_.at(j).oi_occupancy_MSB_align_flag, 1, "oi_occupancy_MSB_align_flag",gofId);
         }
 
         if (vps_geometry_video_present_flag_.at(j)) {
-            WRITE_U(stream, geometry_info_.at(j).gi_geometry_codec_id, 8, "gi_geometry_codec_id");
-            WRITE_U(stream, geometry_info_.at(j).gi_geometry_2d_bit_depth_minus1, 5, "gi_geometry_2d_bit_depth_minus1");
-            WRITE_U(stream, geometry_info_.at(j).gi_geometry_MSB_align_flag, 1, "gi_geometry_MSB_align_flag");
-            WRITE_U(stream, geometry_info_.at(j).gi_geometry_3d_coordinates_bit_depth_minus1, 5,
-                    "gi_geometry_3d_coordinates_bit_depth_minus1");
+            writeU(stream, geometry_info_.at(j).gi_geometry_codec_id, 8, "gi_geometry_codec_id",gofId);
+            writeU(stream, geometry_info_.at(j).gi_geometry_2d_bit_depth_minus1, 5, "gi_geometry_2d_bit_depth_minus1",gofId);
+            writeU(stream, geometry_info_.at(j).gi_geometry_MSB_align_flag, 1, "gi_geometry_MSB_align_flag",gofId);
+            writeU(stream, geometry_info_.at(j).gi_geometry_3d_coordinates_bit_depth_minus1, 5,
+                    "gi_geometry_3d_coordinates_bit_depth_minus1",gofId);
 
             if (vps_auxiliary_video_present_flag_.at(j)) {
-                WRITE_U(stream, geometry_info_.at(j).gi_auxiliary_geometry_codec_id, 8, "gi_auxiliary_geometry_codec_id");
+                writeU(stream, geometry_info_.at(j).gi_auxiliary_geometry_codec_id, 8, "gi_auxiliary_geometry_codec_id",gofId);
             }
         }
 
         if (vps_attribute_video_present_flag_.at(j)) {
-            WRITE_U(stream, attribute_info_.at(j).ai_attribute_count, 7, "ai_attribute_count");
+            writeU(stream, attribute_info_.at(j).ai_attribute_count, 7, "ai_attribute_count",gofId);
 
             for (uint8_t i = 0; i < attribute_info_.at(j).ai_attribute_count; ++i) {
-                WRITE_U(stream, attribute_info_.at(j).ai_attribute_type_id.at(i), 4, "ai_attribute_type_id");
-                WRITE_U(stream, attribute_info_.at(j).ai_attribute_codec_id.at(i), 8, "ai_attribute_codec_id");
+                writeU(stream, attribute_info_.at(j).ai_attribute_type_id.at(i), 4, "ai_attribute_type_id",gofId);
+                writeU(stream, attribute_info_.at(j).ai_attribute_codec_id.at(i), 8, "ai_attribute_codec_id",gofId);
 
                 if (vps_auxiliary_video_present_flag_.at(j)) {
-                    WRITE_U(stream, attribute_info_.at(j).ai_auxiliary_attribute_codec_id.at(i), 8, "ai_auxiliary_attribute_codec_id");
+                    writeU(stream, attribute_info_.at(j).ai_auxiliary_attribute_codec_id.at(i), 8, "ai_auxiliary_attribute_codec_id",gofId);
                 }
                 if (vps_map_count_minus1_.at(j) > 0) {
-                    WRITE_U(stream, int(attribute_info_.at(j).ai_attribute_map_absolute_coding_persistence_flag.at(i)), 1,
-                            "ai_attribute_map_absolute_coding_persistence_flag");
+                    writeU(stream, int(attribute_info_.at(j).ai_attribute_map_absolute_coding_persistence_flag.at(i)), 1,
+                            "ai_attribute_map_absolute_coding_persistence_flag",gofId);
                 }
 
                 uint8_t d = attribute_info_.at(j).ai_attribute_dimension_minus1.at(i);
-                WRITE_U(stream, d, 6, "ai_attribute_dimension_minus1");
+                writeU(stream, d, 6, "ai_attribute_dimension_minus1",gofId);
 
                 uint8_t m = 0;
                 if (d == 0) {  // true
                     m = 0;
                     attribute_info_.at(j).ai_attribute_dimension_partitions_minus1.at(i) = 0;
                 } else {
                     m = attribute_info_.at(j).ai_attribute_dimension_partitions_minus1.at(i);
-                    WRITE_U(stream, attribute_info_.at(j).ai_attribute_dimension_partitions_minus1.at(i), 6,
-                            "ai_attribute_dimension_partitions_minus1");
+                    writeU(stream, attribute_info_.at(j).ai_attribute_dimension_partitions_minus1.at(i), 6,
+                            "ai_attribute_dimension_partitions_minus1",gofId);
                 }
 
                 uint16_t n = 0;
@@ -240,23 +242,23 @@ bool vps::write_vps(bitstream_t* stream) {
                         attribute_info_.at(j).ai_attribute_partition_channels_minus1.at(i).at(k) = 0;
                     } else {
                         n = attribute_info_.at(j).ai_attribute_partition_channels_minus1.at(i).at(k);
-                        WRITE_UE(stream, attribute_info_.at(j).ai_attribute_partition_channels_minus1.at(i).at(k),
-                                 "ai_attribute_partition_channels_minus1");
+                        writeUE(stream, attribute_info_.at(j).ai_attribute_partition_channels_minus1.at(i).at(k),
+                                 "ai_attribute_partition_channels_minus1",gofId);
                     }
                     d -= n + 1;
                 }
                 attribute_info_.at(j).ai_attribute_partition_channels_minus1.at(i).at(m) = d;
 
-                WRITE_U(stream, attribute_info_.at(j).ai_attribute_2d_bit_depth_minus1.at(i), 5, "ai_attribute_2d_bit_depth_minus1");
-                WRITE_U(stream, int(attribute_info_.at(j).ai_attribute_MSB_align_flag.at(i)), 1, "ai_attribute_MSB_align_flag");
+                writeU(stream, attribute_info_.at(j).ai_attribute_2d_bit_depth_minus1.at(i), 5, "ai_attribute_2d_bit_depth_minus1",gofId);
+                writeU(stream, int(attribute_info_.at(j).ai_attribute_MSB_align_flag.at(i)), 1, "ai_attribute_MSB_align_flag",gofId);
             }
         }
-        WRITE_U(stream, vps_extension_present_flag_, 1, "vps_extension_present_flag");
+        writeU(stream, vps_extension_present_flag_, 1, "vps_extension_present_flag",gofId);
 
         if (vps_extension_present_flag_) {
-            WRITE_U(stream, vps_packing_information_present_flag_, 1, "vps_packing_information_present_flag");
-            WRITE_U(stream, vps_miv_extension_present_flag_, 1, "vps_miv_extension_present_flag");
-            WRITE_U(stream, vps_extension_6bits_, 6, "vps_extension_6bits");
+            writeU(stream, vps_packing_information_present_flag_, 1, "vps_packing_information_present_flag",gofId);
+            writeU(stream, vps_miv_extension_present_flag_, 1, "vps_miv_extension_present_flag",gofId);
+            writeU(stream, vps_extension_6bits_, 6, "vps_extension_6bits",gofId);
         }
         // No packing information
         // No MIV extension

src/lib/bitstreamGeneration/vps.cpp

@@ -108,6 +108,8 @@ class vps {
     size_t get_vps_byte_len() { return vps_length_bytes_; };
 
    private:
+    size_t gofId; // lf addition for exporting intermediate atlas information
+
     /* Fill the PTL values in VPS */
     profile_tier_level fill_ptl(size_t& len) const;
 

src/lib/bitstreamGeneration/vps.hpp

@@ -485,4 +485,28 @@ void exportGeometryBitstream(const std::shared_ptr<uvgvpcc_enc::GOF>& gof, const
     exportBitstream(outputPath, bitstream);
 }
 
+//TODO(lf): currently the file is open and close for every log line...
+void exportAtlasInformation(const size_t& gofId, const std::string& logLine) {
+    const std::string filePath = p_->intermediateFilesDir +
+        "/16-atlasInformation/ATLAS_g" + zeroPad(gofId, 3) + ".txt";
+
+    createDirs(filePath);
+
+    std::ofstream textFile(filePath, std::ios::app);
+    if (!textFile.is_open()) {
+        throw std::runtime_error("Unable to open file: " + filePath);
+    }
+
+    textFile << logLine << '\n';
+    if (!textFile) {
+        throw std::runtime_error("Error while writing to file: " + filePath);
+    }
+
+    textFile.close();
+    if (!textFile) {
+        throw std::runtime_error("Error while closing file: " + filePath);
+    }
+}
+
+
 }  // namespace FileExport

src/lib/utils/fileExport.cpp

@@ -32,7 +32,9 @@
 
 /// \file Intermediary files exportation management.
 
+#include <cstddef>
 #include <memory>
+#include <string>
 #include <vector>
 
 #include "utils/utils.hpp"
@@ -72,4 +74,8 @@ void exportAttributeBitstream(const std::shared_ptr<uvgvpcc_enc::GOF>& gof, cons
 void exportGeometryBitstream(const std::shared_ptr<uvgvpcc_enc::GOF>& gof, const std::vector<uint8_t>& bitstream,
                              const std::string& codecExtension);
 
+// Bitstream generation
+void exportAtlasInformation(const size_t& gofId, const std::string& logLine);
+
+
 }  // namespace FileExport