Merge pull request #1098 from paullouisageneau/cleanup

Cleanup

include/rtc/av1rtppacketizer.hpp

@@ -33,15 +33,15 @@ public:
 	// @note RTP configuration is used in packetization process which may change some configuration
 	// properties such as sequence number.
 	AV1RtpPacketizer(Packetization packetization, shared_ptr<RtpPacketizationConfig> rtpConfig,
-	                 uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
+	                 uint16_t maxFragmentSize = NalUnits::defaultMaximumFragmentSize);
 
 	void outgoing(message_vector &messages, const message_callback &send) override;
 
 private:
 	shared_ptr<NalUnits> splitMessage(binary_ptr message);
-	std::vector<shared_ptr<binary>> packetizeObu(binary_ptr message, uint16_t maximumFragmentSize);
+	std::vector<shared_ptr<binary>> packetizeObu(binary_ptr message, uint16_t maxFragmentSize);
 
-	const uint16_t maximumFragmentSize;
+	const uint16_t maxFragmentSize;
 	const Packetization packetization;
 	std::shared_ptr<binary> sequenceHeader;
 };

include/rtc/h264rtppacketizer.hpp

@@ -30,21 +30,21 @@ public:
 	/// properties such as sequence number.
 	/// @param separator NAL unit separator
 	/// @param rtpConfig RTP configuration
-	/// @param maximumFragmentSize maximum size of one NALU fragment
+	/// @param maxFragmentSize maximum size of one NALU fragment
 	H264RtpPacketizer(Separator separator, shared_ptr<RtpPacketizationConfig> rtpConfig,
-	                  uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
+	                  uint16_t maxFragmentSize = NalUnits::defaultMaximumFragmentSize);
 
 	// For backward compatibility, do not use
 	[[deprecated]] H264RtpPacketizer(
 	    shared_ptr<RtpPacketizationConfig> rtpConfig,
-	    uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
+	    uint16_t maxFragmentSize = NalUnits::defaultMaximumFragmentSize);
 
 	void outgoing(message_vector &messages, const message_callback &send) override;
 
 private:
 	shared_ptr<NalUnits> splitMessage(binary_ptr message);
 
-	const uint16_t maximumFragmentSize;
+	const uint16_t maxFragmentSize;
 	const Separator separator;
 };
 

include/rtc/h265nalunit.hpp

@@ -119,7 +119,7 @@ protected:
 /// Nal unit fragment A
 struct RTC_CPP_EXPORT H265NalUnitFragment : H265NalUnit {
 	static std::vector<shared_ptr<H265NalUnitFragment>> fragmentsFrom(shared_ptr<H265NalUnit> nalu,
-	                                                                  uint16_t maximumFragmentSize);
+	                                                                  uint16_t maxFragmentSize);
 
 	enum class FragmentType { Start, Middle, End };
 
@@ -176,7 +176,7 @@ public:
 	static const uint16_t defaultMaximumFragmentSize =
 	    uint16_t(RTC_DEFAULT_MTU - 12 - 8 - 40); // SRTP/UDP/IPv6
 
-	std::vector<shared_ptr<binary>> generateFragments(uint16_t maximumFragmentSize);
+	std::vector<shared_ptr<binary>> generateFragments(uint16_t maxFragmentSize);
 };
 
 } // namespace rtc

include/rtc/h265rtppacketizer.hpp

@@ -29,20 +29,20 @@ public:
 	// properties such as sequence number.
 	// @param separator NAL unit separator
 	// @param rtpConfig  RTP configuration
-	// @param maximumFragmentSize maximum size of one NALU fragment
+	// @param maxFragmentSize maximum size of one NALU fragment
 	H265RtpPacketizer(Separator separator, shared_ptr<RtpPacketizationConfig> rtpConfig,
-	                  uint16_t maximumFragmentSize = H265NalUnits::defaultMaximumFragmentSize);
+	                  uint16_t maxFragmentSize = H265NalUnits::defaultMaximumFragmentSize);
 
 	// for backward compatibility
 	[[deprecated]] H265RtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig,
-	                  uint16_t maximumFragmentSize = H265NalUnits::defaultMaximumFragmentSize);
+	                  uint16_t maxFragmentSize = H265NalUnits::defaultMaximumFragmentSize);
 
 	void outgoing(message_vector &messages, const message_callback &send) override;
 
 private:
 	shared_ptr<H265NalUnits> splitMessage(binary_ptr message);
 
-	const uint16_t maximumFragmentSize;
+	const uint16_t maxFragmentSize;
 	const NalUnit::Separator separator;
 };
 

include/rtc/nalunit.hpp

@@ -159,7 +159,7 @@ protected:
 /// Nal unit fragment A
 struct RTC_CPP_EXPORT NalUnitFragmentA : NalUnit {
 	static std::vector<shared_ptr<NalUnitFragmentA>> fragmentsFrom(shared_ptr<NalUnit> nalu,
-	                                                               uint16_t maximumFragmentSize);
+	                                                               uint16_t maxFragmentSize);
 
 	enum class FragmentType { Start, Middle, End };
 
@@ -216,7 +216,7 @@ public:
 	static const uint16_t defaultMaximumFragmentSize =
 	    uint16_t(RTC_DEFAULT_MTU - 12 - 8 - 40); // SRTP/UDP/IPv6
 
-	std::vector<shared_ptr<binary>> generateFragments(uint16_t maximumFragmentSize);
+	std::vector<shared_ptr<binary>> generateFragments(uint16_t maxFragmentSize);
 };
 
 } // namespace rtc

include/rtc/rtc.h

@@ -13,6 +13,9 @@
 extern "C" {
 #endif
 
+#include <stdbool.h>
+#include <stdint.h>
+
 #ifdef RTC_STATIC
 #define RTC_C_EXPORT
 #else // dynamic library
@@ -27,16 +30,6 @@ extern "C" {
 #endif
 #endif
 
-#ifdef _WIN32
-#ifdef CAPI_STDCALL
-#define RTC_API __stdcall
-#else
-#define RTC_API
-#endif
-#else // not WIN32
-#define RTC_API
-#endif
-
 #ifndef RTC_ENABLE_WEBSOCKET
 #define RTC_ENABLE_WEBSOCKET 1
 #endif
@@ -48,13 +41,30 @@ extern "C" {
 #define RTC_DEFAULT_MTU 1280 // IPv6 minimum guaranteed MTU
 
 #if RTC_ENABLE_MEDIA
-#define RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE                                                          \
-	((uint16_t)(RTC_DEFAULT_MTU - 12 - 8 - 40)) // SRTP/UDP/IPv6
-#define RTC_DEFAULT_MAXIMUM_PACKET_COUNT_FOR_NACK_CACHE ((unsigned)512)
+#define RTC_DEFAULT_MAX_FRAGMENT_SIZE ((uint16_t)(RTC_DEFAULT_MTU - 12 - 8 - 40)) // SRTP/UDP/IPv6
+#define RTC_DEFAULT_MAX_STORED_PACKET_COUNT 512
+// Deprecated, do not use
+#define RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE RTC_DEFAULT_MAX_FRAGMENT_SIZE
+#define RTC_DEFAULT_MAXIMUM_PACKET_COUNT_FOR_NACK_CACHE RTC_DEFAULT_MAX_STORED_PACKET_COUNT
 #endif
 
-#include <stdbool.h>
-#include <stdint.h>
+#ifdef _WIN32
+#ifdef CAPI_STDCALL
+#define RTC_API __stdcall
+#else
+#define RTC_API
+#endif
+#else // not WIN32
+#define RTC_API
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define RTC_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define RTC_DEPRECATED __declspec(deprecated)
+#else
+#define DEPRECATED
+#endif
 
 // libdatachannel C API
 
@@ -320,16 +330,19 @@ typedef struct {
 	uint16_t sequenceNumber;
 	uint32_t timestamp;
 
+	// H264, H265, AV1
+	uint16_t maxFragmentSize; // Maximum fragment size, 0 means default
+
 	// H264/H265 only
 	rtcNalUnitSeparator nalSeparator; // NAL unit separator
 
-	// H264, H265, AV1
-	uint16_t maxFragmentSize; // Maximum fragment size
-
 	// AV1 only
 	rtcObuPacketization obuPacketization; // OBU paketization for AV1 samples
 
-} rtcPacketizationHandlerInit;
+} rtcPacketizerInit;
+
+// Deprecated, do not use
+typedef rtcPacketizerInit rtcPacketizationHandlerInit;
 
 typedef struct {
 	uint32_t ssrc;
@@ -338,8 +351,6 @@ typedef struct {
 	const char *trackId; // optional, track ID used in MSID
 } rtcSsrcForTypeInit;
 
-// Opaque message
-
 // Opaque type used (via rtcMessage*) to reference an rtc::Message
 typedef void *rtcMessage;
 
@@ -349,34 +360,48 @@ typedef void *rtcMessage;
 RTC_C_EXPORT rtcMessage *rtcCreateOpaqueMessage(void *data, int size);
 RTC_C_EXPORT void rtcDeleteOpaqueMessage(rtcMessage *msg);
 
-// Set MediaInterceptor for peer connection
+// Set MediaInterceptor on peer connection
 RTC_C_EXPORT int rtcSetMediaInterceptorCallback(int id, rtcInterceptorCallbackFunc cb);
 
-// Set H264PacketizationHandler for track
-RTC_C_EXPORT int rtcSetH264PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init);
-
-// Set H265PacketizationHandler for track
-RTC_C_EXPORT int rtcSetH265PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init);
-
-// Set AV1PacketizationHandler for track
-RTC_C_EXPORT int rtcSetAV1PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init);
-
-// Set OpusPacketizationHandler for track
-RTC_C_EXPORT int rtcSetOpusPacketizationHandler(int tr, const rtcPacketizationHandlerInit *init);
-
-// Set AACPacketizationHandler for track
-RTC_C_EXPORT int rtcSetAACPacketizationHandler(int tr, const rtcPacketizationHandlerInit *init);
-
-// Set RtcpReceivingSession for track
+// Set a packetizer on track
+RTC_C_EXPORT int rtcSetH264Packetizer(int tr, const rtcPacketizerInit *init);
+RTC_C_EXPORT int rtcSetH265Packetizer(int tr, const rtcPacketizerInit *init);
+RTC_C_EXPORT int rtcSetAV1Packetizer(int tr, const rtcPacketizerInit *init);
+RTC_C_EXPORT int rtcSetOpusPacketizer(int tr, const rtcPacketizerInit *init);
+RTC_C_EXPORT int rtcSetAACPacketizer(int tr, const rtcPacketizerInit *init);
+
+// Deprecated, do not use
+RTC_DEPRECATED static inline int
+rtcSetH264PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+	return rtcSetH264Packetizer(tr, init);
+}
+RTC_DEPRECATED static inline int
+rtcSetH265PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+	return rtcSetH265Packetizer(tr, init);
+}
+RTC_DEPRECATED static inline int
+rtcSetAV1PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+	return rtcSetAV1Packetizer(tr, init);
+}
+RTC_DEPRECATED static inline int
+rtcSetOpusPacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+	return rtcSetOpusPacketizer(tr, init);
+}
+RTC_DEPRECATED static inline int
+rtcSetAACPacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+	return rtcSetAACPacketizer(tr, init);
+}
+
+// Chain RtcpReceivingSession on track
 RTC_C_EXPORT int rtcChainRtcpReceivingSession(int tr);
 
-// Chain RtcpSrReporter to handler chain for given track
+// Chain RtcpSrReporter on track
 RTC_C_EXPORT int rtcChainRtcpSrReporter(int tr);
 
-// Chain RtcpNackResponder to handler chain for given track
+// Chain RtcpNackResponder on track
 RTC_C_EXPORT int rtcChainRtcpNackResponder(int tr, unsigned int maxStoredPacketsCount);
 
-// Chain PliHandler to handler chain for given track
+// Chain PliHandler on track
 RTC_C_EXPORT int rtcChainPliHandler(int tr, rtcPliHandlerCallbackFunc cb);
 
 // Transform seconds to timestamp using track's clock rate, result is written to timestamp

src/av1rtppacketizer.cpp

@@ -117,7 +117,7 @@ std::vector<binary_ptr> extractTemporalUnitObus(binary_ptr message) {
  **/
 
 std::vector<binary_ptr> AV1RtpPacketizer::packetizeObu(binary_ptr message,
-                                                       uint16_t maximumFragmentSize) {
+                                                       uint16_t maxFragmentSize) {
 
 	std::vector<shared_ptr<binary>> payloads{};
 	size_t messageIndex = 0;
@@ -144,7 +144,7 @@ std::vector<binary_ptr> AV1RtpPacketizer::packetizeObu(binary_ptr message,
 		}
 
 		auto payload = std::make_shared<binary>(
-		    std::min(size_t(maximumFragmentSize), messageRemaining + metadataSize));
+		    std::min(size_t(maxFragmentSize), messageRemaining + metadataSize));
 		auto payloadOffset = payloadHeaderSize;
 
 		payload->at(0) = byte(obuCount) << wBitshift;
@@ -187,8 +187,8 @@ std::vector<binary_ptr> AV1RtpPacketizer::packetizeObu(binary_ptr message,
 
 AV1RtpPacketizer::AV1RtpPacketizer(AV1RtpPacketizer::Packetization packetization,
                                    shared_ptr<RtpPacketizationConfig> rtpConfig,
-                                   uint16_t maximumFragmentSize)
-    : RtpPacketizer(rtpConfig), maximumFragmentSize(maximumFragmentSize),
+                                   uint16_t maxFragmentSize)
+    : RtpPacketizer(rtpConfig), maxFragmentSize(maxFragmentSize),
       packetization(packetization) {}
 
 void AV1RtpPacketizer::outgoing(message_vector &messages,
@@ -204,7 +204,7 @@ void AV1RtpPacketizer::outgoing(message_vector &messages,
 
 		std::vector<binary_ptr> fragments;
 		for (auto obu : obus) {
-			auto p = packetizeObu(obu, maximumFragmentSize);
+			auto p = packetizeObu(obu, maxFragmentSize);
 			fragments.insert(fragments.end(), p.begin(), p.end());
 		}
 

src/capi.cpp

@@ -1211,7 +1211,7 @@ int rtcSetMediaInterceptorCallback(int pc, rtcInterceptorCallbackFunc cb) {
 	});
 }
 
-int rtcSetH264PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+int rtcSetH264Packetizer(int tr, const rtcPacketizerInit *init) {
 	return wrap([&] {
 		auto track = getTrack(tr);
 		// create RTP configuration
@@ -1220,7 +1220,7 @@ int rtcSetH264PacketizationHandler(int tr, const rtcPacketizationHandlerInit *in
 		// create packetizer
 		auto nalSeparator = init ? init->nalSeparator : RTC_NAL_SEPARATOR_LENGTH;
 		auto maxFragmentSize = init && init->maxFragmentSize ? init->maxFragmentSize
-		                                                     : RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE;
+		                                                     : RTC_DEFAULT_MAX_FRAGMENT_SIZE;
 		auto packetizer = std::make_shared<H264RtpPacketizer>(
 		    static_cast<rtc::NalUnit::Separator>(nalSeparator), rtpConfig, maxFragmentSize);
 		track->setMediaHandler(packetizer);
@@ -1228,7 +1228,7 @@ int rtcSetH264PacketizationHandler(int tr, const rtcPacketizationHandlerInit *in
 	});
 }
 
-int rtcSetH265PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+int rtcSetH265Packetizer(int tr, const rtcPacketizerInit *init) {
 	return wrap([&] {
 		auto track = getTrack(tr);
 		// create RTP configuration
@@ -1236,7 +1236,7 @@ int rtcSetH265PacketizationHandler(int tr, const rtcPacketizationHandlerInit *in
 		// create packetizer
 		auto nalSeparator = init ? init->nalSeparator : RTC_NAL_SEPARATOR_LENGTH;
 		auto maxFragmentSize = init && init->maxFragmentSize ? init->maxFragmentSize
-		                                                     : RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE;
+		                                                     : RTC_DEFAULT_MAX_FRAGMENT_SIZE;
 		auto packetizer = std::make_shared<H265RtpPacketizer>(
 		    static_cast<rtc::NalUnit::Separator>(nalSeparator), rtpConfig, maxFragmentSize);
 		track->setMediaHandler(packetizer);
@@ -1244,14 +1244,14 @@ int rtcSetH265PacketizationHandler(int tr, const rtcPacketizationHandlerInit *in
 	});
 }
 
-int rtcSetAV1PacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+int rtcSetAV1Packetizer(int tr, const rtcPacketizerInit *init) {
 	return wrap([&] {
 		auto track = getTrack(tr);
 		// create RTP configuration
 		auto rtpConfig = createRtpPacketizationConfig(init);
 		// create packetizer
 		auto maxFragmentSize = init && init->maxFragmentSize ? init->maxFragmentSize
-		                                                     : RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE;
+		                                                     : RTC_DEFAULT_MAX_FRAGMENT_SIZE;
 		auto packetization = init->obuPacketization == RTC_OBU_PACKETIZED_TEMPORAL_UNIT
 		                         ? AV1RtpPacketizer::Packetization::TemporalUnit
 		                         : AV1RtpPacketizer::Packetization::Obu;
@@ -1262,7 +1262,7 @@ int rtcSetAV1PacketizationHandler(int tr, const rtcPacketizationHandlerInit *ini
 	});
 }
 
-int rtcSetOpusPacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+int rtcSetOpusPacketizer(int tr, const rtcPacketizerInit *init) {
 	return wrap([&] {
 		auto track = getTrack(tr);
 		// create RTP configuration
@@ -1275,7 +1275,7 @@ int rtcSetOpusPacketizationHandler(int tr, const rtcPacketizationHandlerInit *in
 	});
 }
 
-int rtcSetAACPacketizationHandler(int tr, const rtcPacketizationHandlerInit *init) {
+int rtcSetAACPacketizer(int tr, const rtcPacketizerInit *init) {
 	return wrap([&] {
 		auto track = getTrack(tr);
 		// create RTP configuration

src/h264rtppacketizer.cpp

@@ -81,20 +81,20 @@ shared_ptr<NalUnits> H264RtpPacketizer::splitMessage(binary_ptr message) {
 }
 
 H264RtpPacketizer::H264RtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig,
-                                     uint16_t maximumFragmentSize)
-    : RtpPacketizer(std::move(rtpConfig)), maximumFragmentSize(maximumFragmentSize),
+                                     uint16_t maxFragmentSize)
+    : RtpPacketizer(std::move(rtpConfig)), maxFragmentSize(maxFragmentSize),
       separator(Separator::Length) {}
 
 H264RtpPacketizer::H264RtpPacketizer(Separator separator,
                                      shared_ptr<RtpPacketizationConfig> rtpConfig,
-                                     uint16_t maximumFragmentSize)
-    : RtpPacketizer(rtpConfig), maximumFragmentSize(maximumFragmentSize), separator(separator) {}
+                                     uint16_t maxFragmentSize)
+    : RtpPacketizer(rtpConfig), maxFragmentSize(maxFragmentSize), separator(separator) {}
 
 void H264RtpPacketizer::outgoing(message_vector &messages, [[maybe_unused]] const message_callback &send) {
 	message_vector result;
 	for(const auto &message : messages) {
 		auto nalus = splitMessage(message);
-		auto fragments = nalus->generateFragments(maximumFragmentSize);
+		auto fragments = nalus->generateFragments(maxFragmentSize);
 		if (fragments.size() == 0)
 			continue;
 

src/h265nalunit.cpp

@@ -29,13 +29,13 @@ H265NalUnitFragment::H265NalUnitFragment(FragmentType type, bool forbiddenBit, u
 }
 
 std::vector<shared_ptr<H265NalUnitFragment>>
-H265NalUnitFragment::fragmentsFrom(shared_ptr<H265NalUnit> nalu, uint16_t maximumFragmentSize) {
-	assert(nalu->size() > maximumFragmentSize);
-	auto fragments_count = ceil(double(nalu->size()) / maximumFragmentSize);
-	maximumFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
+H265NalUnitFragment::fragmentsFrom(shared_ptr<H265NalUnit> nalu, uint16_t maxFragmentSize) {
+	assert(nalu->size() > maxFragmentSize);
+	auto fragments_count = ceil(double(nalu->size()) / maxFragmentSize);
+	maxFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
 
 	// 3 bytes for FU indicator and FU header
-	maximumFragmentSize -= (H265_NAL_HEADER_SIZE + H265_FU_HEADER_SIZE);
+	maxFragmentSize -= (H265_NAL_HEADER_SIZE + H265_FU_HEADER_SIZE);
 	auto f = nalu->forbiddenBit();
 	uint8_t nuhLayerId = nalu->nuhLayerId() & 0x3F;        // 6 bits
 	uint8_t nuhTempIdPlus1 = nalu->nuhTempIdPlus1() & 0x7; // 3 bits
@@ -48,19 +48,19 @@ H265NalUnitFragment::fragmentsFrom(shared_ptr<H265NalUnit> nalu, uint16_t maximu
 		FragmentType fragmentType;
 		if (offset == 0) {
 			fragmentType = FragmentType::Start;
-		} else if (offset + maximumFragmentSize < payload.size()) {
+		} else if (offset + maxFragmentSize < payload.size()) {
 			fragmentType = FragmentType::Middle;
 		} else {
-			if (offset + maximumFragmentSize > payload.size()) {
-				maximumFragmentSize = uint16_t(payload.size() - offset);
+			if (offset + maxFragmentSize > payload.size()) {
+				maxFragmentSize = uint16_t(payload.size() - offset);
 			}
 			fragmentType = FragmentType::End;
 		}
-		fragmentData = {payload.begin() + offset, payload.begin() + offset + maximumFragmentSize};
+		fragmentData = {payload.begin() + offset, payload.begin() + offset + maxFragmentSize};
 		auto fragment = std::make_shared<H265NalUnitFragment>(
 		    fragmentType, f, nuhLayerId, nuhTempIdPlus1, naluType, fragmentData);
 		result.push_back(fragment);
-		offset += maximumFragmentSize;
+		offset += maxFragmentSize;
 	}
 	return result;
 }
@@ -81,12 +81,12 @@ void H265NalUnitFragment::setFragmentType(FragmentType type) {
 	}
 }
 
-std::vector<shared_ptr<binary>> H265NalUnits::generateFragments(uint16_t maximumFragmentSize) {
+std::vector<shared_ptr<binary>> H265NalUnits::generateFragments(uint16_t maxFragmentSize) {
 	vector<shared_ptr<binary>> result{};
 	for (auto nalu : *this) {
-		if (nalu->size() > maximumFragmentSize) {
+		if (nalu->size() > maxFragmentSize) {
 			std::vector<shared_ptr<H265NalUnitFragment>> fragments =
-			    H265NalUnitFragment::fragmentsFrom(nalu, maximumFragmentSize);
+			    H265NalUnitFragment::fragmentsFrom(nalu, maxFragmentSize);
 			result.insert(result.end(), fragments.begin(), fragments.end());
 		} else {
 			result.push_back(nalu);

src/h265rtppacketizer.cpp

@@ -81,21 +81,21 @@ shared_ptr<H265NalUnits> H265RtpPacketizer::splitMessage(binary_ptr message) {
 }
 
 H265RtpPacketizer::H265RtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig,
-                                     uint16_t maximumFragmentSize)
-    : RtpPacketizer(std::move(rtpConfig)), maximumFragmentSize(maximumFragmentSize),
+                                     uint16_t maxFragmentSize)
+    : RtpPacketizer(std::move(rtpConfig)), maxFragmentSize(maxFragmentSize),
       separator(NalUnit::Separator::Length) {}
 
 H265RtpPacketizer::H265RtpPacketizer(NalUnit::Separator separator,
                                      shared_ptr<RtpPacketizationConfig> rtpConfig,
-                                     uint16_t maximumFragmentSize)
-    : RtpPacketizer(std::move(rtpConfig)), maximumFragmentSize(maximumFragmentSize),
+                                     uint16_t maxFragmentSize)
+    : RtpPacketizer(std::move(rtpConfig)), maxFragmentSize(maxFragmentSize),
       separator(separator) {}
 
 void H265RtpPacketizer::outgoing(message_vector &messages, [[maybe_unused]] const message_callback &send) {
 	message_vector result;
 	for (const auto &message : messages) {
 		auto nalus = splitMessage(message);
-		auto fragments = nalus->generateFragments(maximumFragmentSize);
+		auto fragments = nalus->generateFragments(maxFragmentSize);
 		if (fragments.size() == 0)
 			continue;
 

src/nalunit.cpp

@@ -28,13 +28,13 @@ NalUnitFragmentA::NalUnitFragmentA(FragmentType type, bool forbiddenBit, uint8_t
 }
 
 std::vector<shared_ptr<NalUnitFragmentA>>
-NalUnitFragmentA::fragmentsFrom(shared_ptr<NalUnit> nalu, uint16_t maximumFragmentSize) {
-	assert(nalu->size() > maximumFragmentSize);
-	auto fragments_count = ceil(double(nalu->size()) / maximumFragmentSize);
-	maximumFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
+NalUnitFragmentA::fragmentsFrom(shared_ptr<NalUnit> nalu, uint16_t maxFragmentSize) {
+	assert(nalu->size() > maxFragmentSize);
+	auto fragments_count = ceil(double(nalu->size()) / maxFragmentSize);
+	maxFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
 
 	// 2 bytes for FU indicator and FU header
-	maximumFragmentSize -= 2;
+	maxFragmentSize -= 2;
 	auto f = nalu->forbiddenBit();
 	uint8_t nri = nalu->nri() & 0x03;
 	uint8_t naluType = nalu->unitType() & 0x1F;
@@ -46,19 +46,19 @@ NalUnitFragmentA::fragmentsFrom(shared_ptr<NalUnit> nalu, uint16_t maximumFragme
 		FragmentType fragmentType;
 		if (offset == 0) {
 			fragmentType = FragmentType::Start;
-		} else if (offset + maximumFragmentSize < payload.size()) {
+		} else if (offset + maxFragmentSize < payload.size()) {
 			fragmentType = FragmentType::Middle;
 		} else {
-			if (offset + maximumFragmentSize > payload.size()) {
-				maximumFragmentSize = uint16_t(payload.size() - offset);
+			if (offset + maxFragmentSize > payload.size()) {
+				maxFragmentSize = uint16_t(payload.size() - offset);
 			}
 			fragmentType = FragmentType::End;
 		}
-		fragmentData = {payload.begin() + offset, payload.begin() + offset + maximumFragmentSize};
+		fragmentData = {payload.begin() + offset, payload.begin() + offset + maxFragmentSize};
 		auto fragment =
 		    std::make_shared<NalUnitFragmentA>(fragmentType, f, nri, naluType, fragmentData);
 		result.push_back(fragment);
-		offset += maximumFragmentSize;
+		offset += maxFragmentSize;
 	}
 	return result;
 }
@@ -80,12 +80,12 @@ void NalUnitFragmentA::setFragmentType(FragmentType type) {
 	}
 }
 
-std::vector<shared_ptr<binary>> NalUnits::generateFragments(uint16_t maximumFragmentSize) {
+std::vector<shared_ptr<binary>> NalUnits::generateFragments(uint16_t maxFragmentSize) {
 	vector<shared_ptr<binary>> result{};
 	for (auto nalu : *this) {
-		if (nalu->size() > maximumFragmentSize) {
+		if (nalu->size() > maxFragmentSize) {
 			std::vector<shared_ptr<NalUnitFragmentA>> fragments =
-			    NalUnitFragmentA::fragmentsFrom(nalu, maximumFragmentSize);
+			    NalUnitFragmentA::fragmentsFrom(nalu, maxFragmentSize);
 			result.insert(result.end(), fragments.begin(), fragments.end());
 		} else {
 			result.push_back(nalu);