diff --git a/CMakeLists.txt b/CMakeLists.txt index b079433..a550be5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -99,6 +99,7 @@ target_sources(${PROJECT_NAME} PRIVATE src/wrapper_c.cc src/socketfactory.cc src/rtcp_reader.cc + src/v3c_parser.cc ) source_group(src/srtp src/srtp/.*) @@ -152,6 +153,7 @@ target_sources(${PROJECT_NAME} PRIVATE src/srtp/srtcp.hh src/socketfactory.hh src/rtcp_reader.hh + include/uvgrtp/v3c_parser.hh include/uvgrtp/util.hh include/uvgrtp/clock.hh diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index fe45489..214431b 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -13,6 +13,8 @@ add_executable(srtp_zrtp) # SRTP + ZRTP example add_executable(zrtp_multistream) # ZRTP Multistream example add_executable(sync_sender) # Syncing streams example, sender add_executable(sync_receiver) # Syncing streams example, receiver +add_executable(v3c_receiver) +add_executable(v3c_sender) # Sources target_sources(binding PRIVATE binding.cc) @@ -28,6 +30,8 @@ target_sources(srtp_zrtp PRIVATE srtp_zrtp.cc) target_sources(zrtp_multistream PRIVATE zrtp_multistream.cc) target_sources(sync_sender PRIVATE sync_sender.cc) target_sources(sync_receiver PRIVATE sync_receiver.cc) +target_sources(v3c_receiver PRIVATE v3c_receiver.cc) +target_sources(v3c_sender PRIVATE v3c_sender.cc) # set crypto++ to be linked in examples if available if (NOT UVGRTP_DISABLE_CRYPTO AND CRYPTOPP_FOUND) @@ -52,4 +56,6 @@ target_link_libraries(srtp_user PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME}) target_link_libraries(srtp_zrtp PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME}) target_link_libraries(zrtp_multistream PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME}) target_link_libraries(sync_sender PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME}) -target_link_libraries(sync_receiver PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME}) \ No newline at end of file +target_link_libraries(sync_receiver PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME}) +target_link_libraries(v3c_receiver PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME}) +target_link_libraries(v3c_sender PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME}) \ No newline at end of file diff --git a/examples/v3c_receiver.cc b/examples/v3c_receiver.cc new file mode 100644 index 0000000..038493a --- /dev/null +++ b/examples/v3c_receiver.cc @@ -0,0 +1,121 @@ + +#include + +#include +#include +#include + +/* There are two main ways of getting received RTP frames from uvgRTP. + * This example demonstrates the usage of hook function to receive RTP frames. + * + * The advantage of using a hook function is minimal CPU usage and delay between + * uvgRTP receiving the frame and application processing the frame. When using + * the hook method, the application must take care that it is not using the hook + * function for heavy processing since this may block RTP frame reception. + * + * Hook based frame reception is generally recommended for most serious applications, + * but there can be situations where polling method is better, especially if performance + * is not a huge concern or if there needs to be tight control when the frame is + * received by the application. + * + * This example only implements the receiving, but it can be used together with the + * sending example to test the functionality. + */ + + // parameters for this test. You can change these to suit your network environment +constexpr uint16_t LOCAL_PORT = 8890; + +constexpr char LOCAL_ADDRESS[] = "127.0.0.1"; + +// This example runs for 5 seconds +constexpr auto RECEIVE_TIME_S = std::chrono::seconds(10); + +void v3c_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame); +void avc_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame); +void cleanup(uvgrtp::context& ctx, uvgrtp::session* sess, uvgrtp::media_stream* receiver); +uint64_t vbytes_received; +uint64_t abytes_received; + +int main(void) +{ + std::cout << "Starting uvgRTP RTP receive hook example" << std::endl; + + uvgrtp::context ctx; + uvgrtp::session* sess = ctx.create_session(LOCAL_ADDRESS, LOCAL_ADDRESS); + int flags = RCE_RECEIVE_ONLY; + uvgrtp::media_stream* v3c = sess->create_stream(7790, 8890, RTP_FORMAT_V3C, flags); + uvgrtp::media_stream* avc = sess->create_stream(7792, 8892, RTP_FORMAT_H265, flags); + vbytes_received = 0; + abytes_received = 0; + /* Receive hook can be installed and uvgRTP will call this hook when an RTP frame is received + * + * This is a non-blocking operation + * + * If necessary, receive hook can be given an argument and this argument is supplied to + * the receive hook every time the hook is called. This argument could a pointer to application- + * specfic object if the application needs to be called inside the hook + * + * If it's not needed, it should be set to nullptr */ + if (!v3c || v3c->install_receive_hook(nullptr, v3c_receive_hook) != RTP_OK) + { + std::cerr << "Failed to install RTP reception hook"; + cleanup(ctx, sess, v3c); + return EXIT_FAILURE; + } + if (!avc || avc->install_receive_hook(nullptr, avc_receive_hook) != RTP_OK) + { + std::cerr << "Failed to install RTP reception hook"; + cleanup(ctx, sess, avc); + return EXIT_FAILURE; + } + + std::cout << "Waiting incoming packets for " << RECEIVE_TIME_S.count() << " s" << std::endl; + + std::this_thread::sleep_for(RECEIVE_TIME_S); // lets this example run for some time + std::cout << "V3C Total bytes received " << vbytes_received << std::endl; + std::cout << "AVC Total bytes received " << abytes_received << std::endl; + + cleanup(ctx, sess, v3c); + cleanup(ctx, sess, avc); + + return EXIT_SUCCESS; +} + +void v3c_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame) +{ + std::cout << "Received V3C frame, size: " << frame->payload_len << " bytes" << std::endl; + vbytes_received += frame->payload_len; + /* Now we own the frame. Here you could give the frame to the application + * if f.ex "arg" was some application-specific pointer + * + * arg->copy_frame(frame) or whatever + * + * When we're done with the frame, it must be deallocated manually */ + (void)uvgrtp::frame::dealloc_frame(frame); +} +void avc_receive_hook(void* arg, uvgrtp::frame::rtp_frame* frame) +{ + std::cout << "Received AVC frame, size: " << frame->payload_len << " bytes" << std::endl; + abytes_received += frame->payload_len; + /* Now we own the frame. Here you could give the frame to the application + * if f.ex "arg" was some application-specific pointer + * + * arg->copy_frame(frame) or whatever + * + * When we're done with the frame, it must be deallocated manually */ + (void)uvgrtp::frame::dealloc_frame(frame); +} + +void cleanup(uvgrtp::context& ctx, uvgrtp::session* sess, uvgrtp::media_stream* receiver) +{ + if (receiver) + { + sess->destroy_stream(receiver); + } + + if (sess) + { + /* Session must be destroyed manually */ + ctx.destroy_session(sess); + } +} \ No newline at end of file diff --git a/examples/v3c_sender.cc b/examples/v3c_sender.cc new file mode 100644 index 0000000..6cf163e --- /dev/null +++ b/examples/v3c_sender.cc @@ -0,0 +1,107 @@ +#include + +#include +#include +#include +#include +#include + +constexpr char REMOTE_ADDRESS[] = "127.0.0.1"; +constexpr uint16_t REMOTE_PORT = 8890; + +// the parameters of demostration +constexpr size_t PAYLOAD_LEN = 100; +constexpr int AMOUNT_OF_TEST_PACKETS = 100; +constexpr auto END_WAIT = std::chrono::seconds(5); + +//std::string PATH = "C:\\Users\\ngheta\\Documents\\TMIV_A3_C_QP3.bit"; +std::string PATH = "C:\\Users\\ngheta\\Documents\\test_seq3.vpcc"; + +int main(void) +{ + std::cout << "Parsing V3C file" << std::endl; + + /* A V3C Sample stream is divided into 6 types of 'sub-bitstreams' + parameters. + - The ad_map vector holds the locations and sizes of Atlas NAL units in the file (both AD and CAD) + - The vd_map holds the locations and sizes of all video V3C units (OVD, GVD, AVD, PVD) + - First uint64_t is the start position of the unit, second is the size + - With this info you can send the data via different uvgRTP media streams */ + + std::vector> ad_map = {}; + std::vector> vd_map = {}; + + uint64_t len = get_size(PATH); + uint64_t ptr = 0; + char* cbuf = nullptr; + cbuf = get_cmem(PATH, len); + + vuh_vps parameters = {}; + mmap_v3c_file(cbuf, len, parameters, ad_map, vd_map); + + std::cout << "Sending Atlas NAL units via uvgRTP" << std::endl; + + uvgrtp::context ctx; + uvgrtp::session* sess = ctx.create_session(REMOTE_ADDRESS, REMOTE_ADDRESS); + int flags = RCE_SEND_ONLY; + uvgrtp::media_stream* v3c = sess->create_stream(8890, 7790, RTP_FORMAT_V3C, flags); + uvgrtp::media_stream* vid = nullptr; + + // Create the uvgRTP media stream with the correct RTP format + if (parameters.ptl.ptl_profile_codec_group_idc == CODEC_AVC) { + std::cout << "Video codec: AVC Progressive High" << std::endl; + vid = sess->create_stream(8892, 7792, RTP_FORMAT_H264, flags); + } + else if (parameters.ptl.ptl_profile_codec_group_idc == CODEC_HEVC_MAIN10) { + std::cout << "Video codec: HEVC Main10" << std::endl; + vid = sess->create_stream(8892, 7792, RTP_FORMAT_H265, flags); + } + else if (parameters.ptl.ptl_profile_codec_group_idc == CODEC_HEVC444) { + std::cout << "Video codec: HEVC444" << std::endl; + vid = sess->create_stream(8892, 7792, RTP_FORMAT_H265, flags); + } + else if (parameters.ptl.ptl_profile_codec_group_idc == CODEC_VVC_MAIN10) { + std::cout << "Video codec: VVC Main10" << std::endl; + vid = sess->create_stream(8892, 7792, RTP_FORMAT_H266, flags); + } + + + uint64_t v3c_bytes_sent = 0; + uint64_t avc_bytes_sent = 0; + uint64_t send_ptr = 0; + for (auto p : ad_map) + { + std::cout << "Sending frame in location " << p.first << " with size " << p.second << std::endl; + + if (v3c->push_frame((uint8_t*)cbuf + p.first, p.second, RTP_NO_FLAGS) != RTP_OK) + { + std::cout << "Failed to send RTP frame!" << std::endl; + } + else { + v3c_bytes_sent += p.second; + } + } + for (auto p : vd_map) + { + std::cout << "Sending frame in location " << p.first << " with size " << p.second << std::endl; + + if (vid->push_frame((uint8_t*)cbuf + p.first, p.second, RTP_NO_FLAGS) != RTP_OK) + { + std::cout << "Failed to send RTP frame!" << std::endl; + } + else { + avc_bytes_sent += p.second; + } + } + + std::cout << "V3C Sending finished. Total bytes sent " << v3c_bytes_sent << std::endl; + std::cout << "AVC Sending finished. Total bytes sent " << avc_bytes_sent << std::endl; + + sess->destroy_stream(v3c); + sess->destroy_stream(vid); + if (sess) + { + // Session must be destroyed manually + ctx.destroy_session(sess); + } + return EXIT_SUCCESS; +} diff --git a/include/uvgrtp/lib.hh b/include/uvgrtp/lib.hh index e0ba4f1..90e19c2 100644 --- a/include/uvgrtp/lib.hh +++ b/include/uvgrtp/lib.hh @@ -13,3 +13,4 @@ #include "frame.hh" // frame related functions #include "util.hh" // types #include "version.hh" // version +#include "v3c_parser.hh" // v3c parser diff --git a/include/uvgrtp/v3c_parser.hh b/include/uvgrtp/v3c_parser.hh new file mode 100644 index 0000000..0b45c30 --- /dev/null +++ b/include/uvgrtp/v3c_parser.hh @@ -0,0 +1,87 @@ +#pragma once + +#include +#include +#include +#include +#include + +// vuh_unit_type definitions: +constexpr int V3C_VPS = 0; // V3C parameter set +constexpr int V3C_AD = 1; // Atlas data +constexpr int V3C_OVD = 2; // Occupancy video data +constexpr int V3C_GVD = 3; // Geometry video data +constexpr int V3C_AVD = 4; // Attribute video data +constexpr int V3C_PVD = 5; // Packed video data +constexpr int V3C_CAD = 6; // Common atlas data + +constexpr int CODEC_AVC = 0; // AVC Progressive High +constexpr int CODEC_HEVC_MAIN10 = 1; // HEVC Main10 +constexpr int CODEC_HEVC444 = 2; // HEVC444 +constexpr int CODEC_VVC_MAIN10 = 3; // VVC Main10 + +constexpr int V3C_HDR_LEN = 4; // 32 bits for v3c unit header + +constexpr uint8_t VVC_SC = 0x00000001; // VVC Start Code + +struct profile_tier_level { + uint8_t ptl_tier_flag = 0; + uint8_t ptl_profile_codec_group_idc = 0; +}; +struct vuh_vps { + profile_tier_level ptl; +}; +struct vuh_ad { + uint8_t vuh_v3c_parameter_set_id = 0; + uint8_t vuh_atlas_id = 0; +}; +struct vuh_ovd { + uint8_t vuh_v3c_parameter_set_id = 0; + uint8_t vuh_atlas_id = 0; +}; +struct vuh_gvd { + uint8_t vuh_v3c_parameter_set_id = 0; + uint8_t vuh_atlas_id = 0; + uint8_t vuh_map_index = 0; + bool vuh_auxiliary_video_flag = 0; +}; +struct vuh_avd { + uint8_t vuh_v3c_parameter_set_id = 0; + uint8_t vuh_atlas_id = 0; + uint8_t vuh_attribute_index = 0; + uint8_t vuh_attribute_partition_index = 0; + uint8_t vuh_map_index = 0; + bool vuh_auxiliary_video_flag = 0; +}; +struct vuh_pvd { + uint8_t vuh_v3c_parameter_set_id = 0; + uint8_t vuh_atlas_id = 0; +}; +struct vuh_cad { + uint8_t vuh_v3c_parameter_set_id = 0; +}; + +struct v3c_unit_header { + uint8_t vuh_unit_type = 0; + union { + vuh_vps vps; + vuh_ad ad; + vuh_ovd ovd; + vuh_gvd gvd; + vuh_avd avd; + vuh_pvd pvd; + vuh_cad cad; + }; +}; + +uint32_t combineBytes(uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4); +uint32_t combineBytes(uint8_t byte1, uint8_t byte2, uint8_t byte3); +uint32_t combineBytes(uint8_t byte1, uint8_t byte2); + +uint64_t get_size(std::string filename); +char* get_cmem(std::string filename, const size_t& len); + +// ad is for AD and CAD substreams, vd is for all VD substreams +bool mmap_v3c_file(char* cbuf, uint64_t len, vuh_vps& param, std::vector>& ad, + std::vector>& vd); +void parse_v3c_header(v3c_unit_header &hdr, char* buf, uint64_t ptr); \ No newline at end of file diff --git a/src/v3c_parser.cc b/src/v3c_parser.cc new file mode 100644 index 0000000..4371abb --- /dev/null +++ b/src/v3c_parser.cc @@ -0,0 +1,253 @@ +#include "uvgrtp/v3c_parser.hh" + +uint32_t combineBytes(uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4) { + return (static_cast(byte1) << 24) | + (static_cast(byte2) << 16) | + (static_cast(byte3) << 8) | + static_cast(byte4); +} + +uint32_t combineBytes(uint8_t byte1, uint8_t byte2, uint8_t byte3) { + return (static_cast(byte1) << 16) | + (static_cast(byte2) << 8) | + static_cast(byte3); +} + +uint32_t combineBytes(uint8_t byte1, uint8_t byte2) { + return (static_cast(byte1) << 8) | + (static_cast(byte2)); +} + +bool mmap_v3c_file(char* cbuf, uint64_t len, vuh_vps& param, std::vector>& ad, + std::vector>& vd) +{ + uint64_t ptr = 0; + + // First byte is the file header + uint8_t first_byte = cbuf[ptr]; + std::cout << "First byte " << uint32_t(first_byte) << std::endl; + uint8_t v3c_size_precision = (first_byte >> 5) + 1; + std::cout << "V3C size precision: " << (uint32_t)v3c_size_precision << std::endl; + std::cout << std::endl; + ++ptr; + + uint8_t* v3c_size = new uint8_t[v3c_size_precision]; + + std::vector sizes = {}; + while (true) { + if (ptr >= len) { + break; + } + // Readthe V3C unit size (2-3 bytes usually) + memcpy(v3c_size, &cbuf[ptr], v3c_size_precision); + ptr += v3c_size_precision; // Jump over the V3C unit size bytes + uint32_t combined_v3c_size = 0; + if (v3c_size_precision == 2) { + combined_v3c_size = combineBytes(v3c_size[0], v3c_size[1]); + } + else if (v3c_size_precision == 3) { + combined_v3c_size = combineBytes(v3c_size[0], v3c_size[1], v3c_size[2]); + } + else { + std::cout << "Error " << std::endl; + return EXIT_FAILURE; + } + // Inside v3c unit now + std::cout << "Current V3C unit size " << combined_v3c_size << std::endl; + uint64_t v3c_ptr = ptr; + + // Next 4 bytes are the V3C unit header + v3c_unit_header v3c_hdr = {}; + parse_v3c_header(v3c_hdr, cbuf, v3c_ptr); + uint8_t vuh_t = v3c_hdr.vuh_unit_type; + std::cout << "-- vuh_unit_type: " << (uint32_t)vuh_t << std::endl; + + if (vuh_t == V3C_VPS) { + // Parameter set contains no NAL units, skip over + std::cout << "-- Parameter set V3C unit" << std::endl; + ptr += combined_v3c_size; + sizes.push_back(combined_v3c_size); + param = v3c_hdr.vps; + std::cout << std::endl; + continue; + } + else if (vuh_t == V3C_OVD || vuh_t == V3C_GVD || vuh_t == V3C_AVD || vuh_t == V3C_PVD) { + // Video data, map start and size + std::cout << "-- Video data V3C unit, " << std::endl; + vd.push_back({ ptr + V3C_HDR_LEN, combined_v3c_size }); + ptr += combined_v3c_size; + std::cout << std::endl; + continue; + } + + // Rest of the function goes inside the V3C unit payload and parses NAL it into NAL units + v3c_ptr += V3C_HDR_LEN; // Jump over 4 bytes of V3C unit header + + uint8_t v3cu_first_byte = cbuf[v3c_ptr]; // Next up is 1 byte of NAL unit size precision + uint8_t nal_size_precision = (v3cu_first_byte >> 5) + 1; + std::cout << " -- NAL Sample stream, 1 byte for NAL unit size precision: " << (uint32_t)nal_size_precision << std::endl; + ++v3c_ptr; + + // Now start to parse the NAL sample stream + while (true) { + if (v3c_ptr >= (ptr + combined_v3c_size)) { + break; + } + uint32_t combined_nal_size = 0; + if (nal_size_precision == 2) { + combined_nal_size = combineBytes(cbuf[v3c_ptr], cbuf[v3c_ptr + 1]); + } + else if (nal_size_precision == 3) { + combined_nal_size = combineBytes(cbuf[v3c_ptr], cbuf[v3c_ptr + 1], cbuf[v3c_ptr + 2]); + } + else { + std::cout << " -- Error, invalid NAL size " << std::endl; + return EXIT_FAILURE; + } + v3c_ptr += nal_size_precision; + std::cout << " -- NALU size: " << combined_nal_size << std::endl; + switch (vuh_t) { + case V3C_AD: + case V3C_CAD: + ad.push_back({ v3c_ptr, combined_nal_size }); + break; + + } + v3c_ptr += combined_nal_size; + } + + + + std::cout << std::endl; + ptr += combined_v3c_size; + sizes.push_back(combined_v3c_size); + } + std::cout << "File parsed" << std::endl; + return true; +} + +void parse_v3c_header(v3c_unit_header &hdr, char* buf, uint64_t ptr) +{ + uint8_t vuh_unit_type = (buf[ptr] & 0b11111000) >> 3; + hdr.vuh_unit_type = vuh_unit_type; + + uint8_t vuh_v3c_parameter_set_id = 0;; + uint8_t vuh_atlas_id = 0; + + if (vuh_unit_type == V3C_AVD || vuh_unit_type == V3C_GVD || + vuh_unit_type == V3C_OVD || vuh_unit_type == V3C_AD || + vuh_unit_type == V3C_CAD || vuh_unit_type == V3C_PVD) { + + // 3 last bits from first byte and 1 first bit from second byte + vuh_v3c_parameter_set_id = ((buf[ptr] & 0b111) << 1) | ((buf[ptr + 1] & 0b10000000) >> 7); + std::cout << "-- vuh_v3c_parameter_set_id: " << (uint32_t)vuh_v3c_parameter_set_id << std::endl; + } + if (vuh_unit_type == V3C_AVD || vuh_unit_type == V3C_GVD || + vuh_unit_type == V3C_OVD || vuh_unit_type == V3C_AD || + vuh_unit_type == V3C_PVD) { + + // 6 middle bits from the second byte + vuh_atlas_id = ((buf[ptr + 1] & 0b01111110) >> 1); + std::cout << "-- vuh_atlas_id: " << (uint32_t)vuh_atlas_id << std::endl; + } + + switch (hdr.vuh_unit_type) { + case V3C_VPS: + hdr.vps = {}; + // first bit of first byte + hdr.vps.ptl.ptl_tier_flag = buf[ptr + 4] >> 7; + std::cout << "-- ptl_tier_flag: " << (uint32_t)hdr.vps.ptl.ptl_tier_flag << std::endl; + // 7 bits after + hdr.vps.ptl.ptl_profile_codec_group_idc = buf[ptr + 4] & 0b01111111; + std::cout << "-- ptl_profile_codec_group_idc: " << (uint32_t)hdr.vps.ptl.ptl_profile_codec_group_idc << std::endl; + break; + + case V3C_AD: + hdr.ad = {}; + hdr.ad.vuh_v3c_parameter_set_id = vuh_v3c_parameter_set_id; + hdr.ad.vuh_atlas_id = vuh_atlas_id; + break; + + case V3C_OVD: + hdr.ovd = {}; + hdr.ovd.vuh_v3c_parameter_set_id = vuh_v3c_parameter_set_id; + hdr.ovd.vuh_atlas_id = vuh_atlas_id; + break; + + case V3C_GVD: + hdr.gvd = {}; + hdr.gvd.vuh_v3c_parameter_set_id = vuh_v3c_parameter_set_id; + hdr.gvd.vuh_atlas_id = vuh_atlas_id; + // last bit of second byte and 3 first bytes of third byte + hdr.gvd.vuh_map_index = ((buf[ptr + 1] & 0b1) << 3) | ((buf[ptr + 2] & 0b11100000) >> 5); + std::cout << "-- vuh_map_index: " << (uint32_t)hdr.gvd.vuh_map_index << std::endl; + // fourth bit of third byte + hdr.gvd.vuh_auxiliary_video_flag = (buf[ptr + 2] & 0b00010000) >> 4; + std::cout << "-- vuh_auxiliary_video_flag: " << (uint32_t)hdr.gvd.vuh_auxiliary_video_flag << std::endl; + break; + + case V3C_AVD: + hdr.avd = {}; + hdr.avd.vuh_v3c_parameter_set_id = vuh_v3c_parameter_set_id; + hdr.avd.vuh_atlas_id = vuh_atlas_id; + // last bit of second byte and 6 first bytes of third byte + hdr.avd.vuh_attribute_index = ((buf[ptr + 1] & 0b1) << 6) | ((buf[ptr + 2] & 0b11111100) >> 2); + std::cout << "-- vuh_attribute_index: " << (uint32_t)hdr.avd.vuh_attribute_index << std::endl; + // 2 last bits of third byte and 3 first b�ts of fourth byte + hdr.avd.vuh_attribute_partition_index = (buf[ptr + 2] & 0b11) | ((buf[ptr + 3] & 0b11100000) >> 5); + std::cout << "-- vuh_attribute_partition_index: " << (uint32_t)hdr.avd.vuh_attribute_index << std::endl; + // fourth byte: 4 bits + hdr.avd.vuh_map_index = (buf[ptr + 3] & 0b00011110) >> 1; + std::cout << "-- vuh_map_index: " << (uint32_t)hdr.avd.vuh_map_index << std::endl; + // last bit of fourth byte + hdr.avd.vuh_auxiliary_video_flag = (buf[ptr + 3] & 0b1); + std::cout << "-- vuh_auxiliary_video_flag: " << (uint32_t)hdr.avd.vuh_auxiliary_video_flag << std::endl; + break; + + case V3C_PVD: + hdr.pvd = {}; + hdr.pvd.vuh_v3c_parameter_set_id = vuh_v3c_parameter_set_id; + hdr.pvd.vuh_atlas_id = vuh_atlas_id; + break; + + case V3C_CAD: + hdr.cad = {}; + hdr.cad.vuh_v3c_parameter_set_id = vuh_v3c_parameter_set_id; + break; + + default: + break; + } + return; +} + +uint64_t get_size(std::string filename) +{ + std::ifstream infile(filename, std::ios_base::binary); + + + //get length of file + infile.seekg(0, infile.end); + size_t length = infile.tellg(); + infile.seekg(0, infile.beg); + + return length; +} + +char* get_cmem(std::string filename, const size_t& len) +{ + std::ifstream infile(filename, std::ios_base::binary); + + char* buf = new char[len]; + // read into char* + if (!(infile.read(buf, len))) // read up to the size of the buffer + { + if (!infile.eof()) + { + std::cerr << "Failed to read file contents." << std::endl; + delete[] buf; // Free memory before returning nullptr + return nullptr; + } + } + return buf; +} \ No newline at end of file