v3c: Add example for parsing and sending V3C files
This commit is contained in:
parent
b5905bcae2
commit
a3598cd6c4
|
@ -99,6 +99,7 @@ target_sources(${PROJECT_NAME} PRIVATE
|
||||||
src/wrapper_c.cc
|
src/wrapper_c.cc
|
||||||
src/socketfactory.cc
|
src/socketfactory.cc
|
||||||
src/rtcp_reader.cc
|
src/rtcp_reader.cc
|
||||||
|
src/v3c_parser.cc
|
||||||
)
|
)
|
||||||
|
|
||||||
source_group(src/srtp src/srtp/.*)
|
source_group(src/srtp src/srtp/.*)
|
||||||
|
@ -152,6 +153,7 @@ target_sources(${PROJECT_NAME} PRIVATE
|
||||||
src/srtp/srtcp.hh
|
src/srtp/srtcp.hh
|
||||||
src/socketfactory.hh
|
src/socketfactory.hh
|
||||||
src/rtcp_reader.hh
|
src/rtcp_reader.hh
|
||||||
|
include/uvgrtp/v3c_parser.hh
|
||||||
|
|
||||||
include/uvgrtp/util.hh
|
include/uvgrtp/util.hh
|
||||||
include/uvgrtp/clock.hh
|
include/uvgrtp/clock.hh
|
||||||
|
|
|
@ -13,6 +13,8 @@ add_executable(srtp_zrtp) # SRTP + ZRTP example
|
||||||
add_executable(zrtp_multistream) # ZRTP Multistream example
|
add_executable(zrtp_multistream) # ZRTP Multistream example
|
||||||
add_executable(sync_sender) # Syncing streams example, sender
|
add_executable(sync_sender) # Syncing streams example, sender
|
||||||
add_executable(sync_receiver) # Syncing streams example, receiver
|
add_executable(sync_receiver) # Syncing streams example, receiver
|
||||||
|
add_executable(v3c_receiver)
|
||||||
|
add_executable(v3c_sender)
|
||||||
|
|
||||||
# Sources
|
# Sources
|
||||||
target_sources(binding PRIVATE binding.cc)
|
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(zrtp_multistream PRIVATE zrtp_multistream.cc)
|
||||||
target_sources(sync_sender PRIVATE sync_sender.cc)
|
target_sources(sync_sender PRIVATE sync_sender.cc)
|
||||||
target_sources(sync_receiver PRIVATE sync_receiver.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
|
# set crypto++ to be linked in examples if available
|
||||||
if (NOT UVGRTP_DISABLE_CRYPTO AND CRYPTOPP_FOUND)
|
if (NOT UVGRTP_DISABLE_CRYPTO AND CRYPTOPP_FOUND)
|
||||||
|
@ -53,3 +57,5 @@ target_link_libraries(srtp_zrtp PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME})
|
||||||
target_link_libraries(zrtp_multistream 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_sender PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME})
|
||||||
target_link_libraries(sync_receiver PRIVATE uvgrtp ${CRYPTOPP_LIB_NAME})
|
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})
|
|
@ -0,0 +1,121 @@
|
||||||
|
|
||||||
|
#include <uvgrtp/lib.hh>
|
||||||
|
|
||||||
|
#include <thread>
|
||||||
|
#include <iostream>
|
||||||
|
#include <fstream>
|
||||||
|
|
||||||
|
/* 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);
|
||||||
|
}
|
||||||
|
}
|
|
@ -0,0 +1,107 @@
|
||||||
|
#include <uvgrtp/lib.hh>
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <fstream>
|
||||||
|
#include <cstring>
|
||||||
|
#include <vector>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
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<std::pair<uint64_t, uint64_t>> ad_map = {};
|
||||||
|
std::vector<std::pair<uint64_t, uint64_t>> 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;
|
||||||
|
}
|
|
@ -13,3 +13,4 @@
|
||||||
#include "frame.hh" // frame related functions
|
#include "frame.hh" // frame related functions
|
||||||
#include "util.hh" // types
|
#include "util.hh" // types
|
||||||
#include "version.hh" // version
|
#include "version.hh" // version
|
||||||
|
#include "v3c_parser.hh" // v3c parser
|
||||||
|
|
|
@ -0,0 +1,87 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <fstream>
|
||||||
|
#include <cstring>
|
||||||
|
#include <vector>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
// 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<std::pair<uint64_t, uint64_t>>& ad,
|
||||||
|
std::vector<std::pair<uint64_t, uint64_t>>& vd);
|
||||||
|
void parse_v3c_header(v3c_unit_header &hdr, char* buf, uint64_t ptr);
|
|
@ -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<uint32_t>(byte1) << 24) |
|
||||||
|
(static_cast<uint32_t>(byte2) << 16) |
|
||||||
|
(static_cast<uint32_t>(byte3) << 8) |
|
||||||
|
static_cast<uint32_t>(byte4);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t combineBytes(uint8_t byte1, uint8_t byte2, uint8_t byte3) {
|
||||||
|
return (static_cast<uint32_t>(byte1) << 16) |
|
||||||
|
(static_cast<uint32_t>(byte2) << 8) |
|
||||||
|
static_cast<uint32_t>(byte3);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t combineBytes(uint8_t byte1, uint8_t byte2) {
|
||||||
|
return (static_cast<uint32_t>(byte1) << 8) |
|
||||||
|
(static_cast<uint32_t>(byte2));
|
||||||
|
}
|
||||||
|
|
||||||
|
bool mmap_v3c_file(char* cbuf, uint64_t len, vuh_vps& param, std::vector<std::pair<uint64_t, uint64_t>>& ad,
|
||||||
|
std::vector<std::pair<uint64_t, uint64_t>>& 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<uint32_t> 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;
|
||||||
|
}
|
Loading…
Reference in New Issue