Add H264RtpDepacketizer

Inverse of H264RtpPacketizer. Takes incoming H264 packets and emits H264
NALUs.

Author: Sean-Der

CMakeLists.txt

@@ -76,6 +76,7 @@ set(LIBDATACHANNEL_SOURCES
 	${CMAKE_CURRENT_SOURCE_DIR}/src/rtcpsrreporter.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/rtppacketizer.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/h264rtppacketizer.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/h264rtpdepacketizer.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/nalunit.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/h265rtppacketizer.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/h265nalunit.cpp
@@ -110,6 +111,7 @@ set(LIBDATACHANNEL_HEADERS
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtcpsrreporter.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtppacketizer.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/h264rtppacketizer.hpp
+	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/h264rtpdepacketizer.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/nalunit.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/h265rtppacketizer.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/h265nalunit.hpp

include/rtc/h264rtpdepacketizer.hpp

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2020 Staz Modrzynski
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#ifndef RTC_H264_RTP_DEPACKETIZER_H
+#define RTC_H264_RTP_DEPACKETIZER_H
+
+#if RTC_ENABLE_MEDIA
+
+#include "common.hpp"
+#include "mediahandler.hpp"
+#include "message.hpp"
+#include "rtp.hpp"
+
+#include <iterator>
+
+namespace rtc {
+
+/// RTP depacketization for H264
+class RTC_CPP_EXPORT H264RtpDepacketizer : public MediaHandler {
+public:
+	H264RtpDepacketizer() = default;
+	virtual ~H264RtpDepacketizer() = default;
+
+	void incoming(message_vector &messages, const message_callback &send) override;
+
+private:
+	std::vector<message_ptr> rtp_buffer;
+
+	message_vector buildFrame(message_vector::iterator firstPkt, message_vector::iterator lastPkt);
+};
+
+} // namespace rtc
+
+#endif // RTC_ENABLE_MEDIA
+
+#endif /* RTC_H264_RTP_DEPACKETIZER_H */

include/rtc/rtc.hpp

@@ -30,6 +30,7 @@
 // Media
 #include "av1rtppacketizer.hpp"
 #include "h264rtppacketizer.hpp"
+#include "h264rtpdepacketizer.hpp"
 #include "h265rtppacketizer.hpp"
 #include "mediahandler.hpp"
 #include "plihandler.hpp"

src/h264rtpdepacketizer.cpp

@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2023 Paul-Louis Ageneau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#if RTC_ENABLE_MEDIA
+
+#include "h264rtpdepacketizer.hpp"
+#include "track.hpp"
+
+#include "impl/logcounter.hpp"
+
+#include <cmath>
+#include <utility>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+namespace rtc {
+
+const unsigned long stapaHeaderSize = 1;
+const auto fuaHeaderSize = 2;
+const auto rtpHeaderSize = 12;
+
+const auto naluTypeBitmask = std::byte(0x1F);
+const auto naluTypeSTAPA = std::byte(24);
+const auto naluTypeFUA = std::byte(28);
+const auto fuaEndBitmask = std::byte(0x40);
+const auto naluRefIdcBitmask = std::byte(0x60);
+
+message_vector H264RtpDepacketizer::buildFrame(message_vector::iterator first,
+                                               message_vector::iterator last) {
+	message_vector out = {};
+	auto fua_buffer = std::vector<std::byte>{};
+
+	for (auto it = first; (it - 1) != last; it++) {
+		auto pkt = it->get();
+		auto pktParsed = reinterpret_cast<const rtc::RtpHeader *>(pkt->data());
+		auto headerSize =
+		    rtpHeaderSize + pktParsed->csrcCount() + pktParsed->getExtensionHeaderSize();
+		auto naluType = pkt->at(headerSize) & naluTypeBitmask;
+
+		if (fua_buffer.size() != 0 || naluType == naluTypeFUA) {
+			if (fua_buffer.size() == 0) {
+				fua_buffer.push_back(std::byte(0));
+			}
+
+			std::copy(pkt->begin() + headerSize + fuaHeaderSize, pkt->end(),
+			          std::back_inserter(fua_buffer));
+
+			if ((pkt->at(headerSize + 1) & fuaEndBitmask) != std::byte(0)) {
+				auto naluRefIdc = pkt->at(headerSize) & naluRefIdcBitmask;
+				auto fragmentedNaluType = pkt->at(headerSize + 1) & std::byte(naluTypeBitmask);
+				fua_buffer.at(0) = naluRefIdc | fragmentedNaluType;
+
+				out.push_back(make_message(fua_buffer));
+				fua_buffer.clear();
+			}
+		} else if (naluType > std::byte(0) && naluType < std::byte(24)) {
+			out.push_back(make_message(pkt->begin() + headerSize, pkt->end()));
+		} else if (naluType == naluTypeSTAPA) {
+			auto currOffset = stapaHeaderSize + headerSize;
+
+			while (currOffset < pkt->size()) {
+				auto naluSize =
+				    uint16_t(pkt->at(currOffset)) << 8 | uint8_t(pkt->at(currOffset + 1));
+
+				currOffset += 2;
+
+				if (pkt->size() < currOffset + naluSize) {
+					throw std::runtime_error("STAP-A declared size is larger then buffer");
+				}
+
+				out.push_back(
+				    make_message(pkt->begin() + currOffset, pkt->begin() + currOffset + naluSize));
+				currOffset += naluSize;
+			}
+
+		} else {
+			throw std::runtime_error("Unknown H264 RTP Packetization");
+		}
+	}
+
+	return out;
+}
+
+void H264RtpDepacketizer::incoming(message_vector &messages, const message_callback &) {
+	for (auto message : messages) {
+		if (message->type != Message::Binary) {
+			continue;
+		}
+
+		if (message->size() < sizeof(RtpHeader)) {
+			PLOG_VERBOSE << "RTP packet is too small, size=" << message->size();
+			continue;
+		}
+
+		this->rtp_buffer.push_back(make_message(message->begin(), message->end()));
+	}
+
+	while (this->rtp_buffer.size() != 0) {
+		uint32_t current_timestamp = 0;
+		size_t packets_in_timestamp = 0;
+
+		for (const auto &pkt : this->rtp_buffer) {
+			auto p = reinterpret_cast<const rtc::RtpHeader *>(pkt->data());
+
+			if (current_timestamp == 0) {
+				current_timestamp = p->timestamp();
+			} else if (current_timestamp != p->timestamp()) {
+				break;
+			}
+
+			packets_in_timestamp++;
+		}
+
+		if (packets_in_timestamp == this->rtp_buffer.size()) {
+			break;
+		}
+
+		auto first = this->rtp_buffer.begin();
+		auto last = this->rtp_buffer.begin() + (packets_in_timestamp - 1);
+
+		messages = buildFrame(first, last);
+		this->rtp_buffer.erase(this->rtp_buffer.begin(),
+		                       this->rtp_buffer.begin() + packets_in_timestamp);
+	}
+}
+
+} // namespace rtc
+
+#endif // RTC_ENABLE_MEDIA