Skip to content

Commit cb86efc

Browse files
paullouisageneaupaullouisageneau
committed
Renamed maximumFragmentSize to maxFragmentSize
1 parent 7ea19e9 commit cb86efc

12 files changed

+64
-62
lines changed

‎include/rtc/av1rtppacketizer.hpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -33,15 +33,15 @@ class RTC_CPP_EXPORT AV1RtpPacketizer final : public RtpPacketizer {
3333
// @note RTP configuration is used in packetization process which may change some configuration
3434
// properties such as sequence number.
3535
AV1RtpPacketizer(Packetization packetization, shared_ptr<RtpPacketizationConfig> rtpConfig,
36-
uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
36+
uint16_t maxFragmentSize = NalUnits::defaultMaximumFragmentSize);
3737

3838
void outgoing(message_vector &messages, const message_callback &send) override;
3939

4040
private:
4141
shared_ptr<NalUnits> splitMessage(binary_ptr message);
42-
std::vector<shared_ptr<binary>> packetizeObu(binary_ptr message, uint16_t maximumFragmentSize);
42+
std::vector<shared_ptr<binary>> packetizeObu(binary_ptr message, uint16_t maxFragmentSize);
4343

44-
const uint16_t maximumFragmentSize;
44+
const uint16_t maxFragmentSize;
4545
const Packetization packetization;
4646
std::shared_ptr<binary> sequenceHeader;
4747
};

‎include/rtc/h264rtppacketizer.hpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -30,21 +30,21 @@ class RTC_CPP_EXPORT H264RtpPacketizer final : public RtpPacketizer {
3030
/// properties such as sequence number.
3131
/// @param separator NAL unit separator
3232
/// @param rtpConfig RTP configuration
33-
/// @param maximumFragmentSize maximum size of one NALU fragment
33+
/// @param maxFragmentSize maximum size of one NALU fragment
3434
H264RtpPacketizer(Separator separator, shared_ptr<RtpPacketizationConfig> rtpConfig,
35-
uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
35+
uint16_t maxFragmentSize = NalUnits::defaultMaximumFragmentSize);
3636

3737
// For backward compatibility, do not use
3838
[[deprecated]] H264RtpPacketizer(
3939
shared_ptr<RtpPacketizationConfig> rtpConfig,
40-
uint16_t maximumFragmentSize = NalUnits::defaultMaximumFragmentSize);
40+
uint16_t maxFragmentSize = NalUnits::defaultMaximumFragmentSize);
4141

4242
void outgoing(message_vector &messages, const message_callback &send) override;
4343

4444
private:
4545
shared_ptr<NalUnits> splitMessage(binary_ptr message);
4646

47-
const uint16_t maximumFragmentSize;
47+
const uint16_t maxFragmentSize;
4848
const Separator separator;
4949
};
5050

‎include/rtc/h265nalunit.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -119,7 +119,7 @@ struct RTC_CPP_EXPORT H265NalUnit : NalUnit {
119119
/// Nal unit fragment A
120120
struct RTC_CPP_EXPORT H265NalUnitFragment : H265NalUnit {
121121
static std::vector<shared_ptr<H265NalUnitFragment>> fragmentsFrom(shared_ptr<H265NalUnit> nalu,
122-
uint16_t maximumFragmentSize);
122+
uint16_t maxFragmentSize);
123123

124124
enum class FragmentType { Start, Middle, End };
125125

@@ -176,7 +176,7 @@ class RTC_CPP_EXPORT H265NalUnits : public std::vector<shared_ptr<H265NalUnit>>
176176
static const uint16_t defaultMaximumFragmentSize =
177177
uint16_t(RTC_DEFAULT_MTU - 12 - 8 - 40); // SRTP/UDP/IPv6
178178

179-
std::vector<shared_ptr<binary>> generateFragments(uint16_t maximumFragmentSize);
179+
std::vector<shared_ptr<binary>> generateFragments(uint16_t maxFragmentSize);
180180
};
181181

182182
} // namespace rtc

‎include/rtc/h265rtppacketizer.hpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -29,20 +29,20 @@ class RTC_CPP_EXPORT H265RtpPacketizer final : public RtpPacketizer {
2929
// properties such as sequence number.
3030
// @param separator NAL unit separator
3131
// @param rtpConfig RTP configuration
32-
// @param maximumFragmentSize maximum size of one NALU fragment
32+
// @param maxFragmentSize maximum size of one NALU fragment
3333
H265RtpPacketizer(Separator separator, shared_ptr<RtpPacketizationConfig> rtpConfig,
34-
uint16_t maximumFragmentSize = H265NalUnits::defaultMaximumFragmentSize);
34+
uint16_t maxFragmentSize = H265NalUnits::defaultMaximumFragmentSize);
3535

3636
// for backward compatibility
3737
[[deprecated]] H265RtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig,
38-
uint16_t maximumFragmentSize = H265NalUnits::defaultMaximumFragmentSize);
38+
uint16_t maxFragmentSize = H265NalUnits::defaultMaximumFragmentSize);
3939

4040
void outgoing(message_vector &messages, const message_callback &send) override;
4141

4242
private:
4343
shared_ptr<H265NalUnits> splitMessage(binary_ptr message);
4444

45-
const uint16_t maximumFragmentSize;
45+
const uint16_t maxFragmentSize;
4646
const NalUnit::Separator separator;
4747
};
4848

‎include/rtc/nalunit.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -159,7 +159,7 @@ struct RTC_CPP_EXPORT NalUnit : binary {
159159
/// Nal unit fragment A
160160
struct RTC_CPP_EXPORT NalUnitFragmentA : NalUnit {
161161
static std::vector<shared_ptr<NalUnitFragmentA>> fragmentsFrom(shared_ptr<NalUnit> nalu,
162-
uint16_t maximumFragmentSize);
162+
uint16_t maxFragmentSize);
163163

164164
enum class FragmentType { Start, Middle, End };
165165

@@ -216,7 +216,7 @@ class RTC_CPP_EXPORT NalUnits : public std::vector<shared_ptr<NalUnit>> {
216216
static const uint16_t defaultMaximumFragmentSize =
217217
uint16_t(RTC_DEFAULT_MTU - 12 - 8 - 40); // SRTP/UDP/IPv6
218218

219-
std::vector<shared_ptr<binary>> generateFragments(uint16_t maximumFragmentSize);
219+
std::vector<shared_ptr<binary>> generateFragments(uint16_t maxFragmentSize);
220220
};
221221

222222
} // namespace rtc

‎include/rtc/rtc.h

+5-3
Original file line numberDiff line numberDiff line change
@@ -41,9 +41,11 @@ extern "C" {
4141
#define RTC_DEFAULT_MTU 1280 // IPv6 minimum guaranteed MTU
4242

4343
#if RTC_ENABLE_MEDIA
44-
#define RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE \
45-
((uint16_t)(RTC_DEFAULT_MTU - 12 - 8 - 40)) // SRTP/UDP/IPv6
46-
#define RTC_DEFAULT_MAXIMUM_PACKET_COUNT_FOR_NACK_CACHE ((unsigned)512)
44+
#define RTC_DEFAULT_MAX_FRAGMENT_SIZE ((uint16_t)(RTC_DEFAULT_MTU - 12 - 8 - 40)) // SRTP/UDP/IPv6
45+
#define RTC_DEFAULT_MAX_STORED_PACKET_COUNT 512
46+
// Deprecated, do not use
47+
#define RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE RTC_DEFAULT_MAX_FRAGMENT_SIZE
48+
#define RTC_DEFAULT_MAXIMUM_PACKET_COUNT_FOR_NACK_CACHE RTC_DEFAULT_MAX_STORED_PACKET_COUNT
4749
#endif
4850

4951
#ifdef _WIN32

‎src/av1rtppacketizer.cpp

+5-5
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,7 @@ std::vector<binary_ptr> extractTemporalUnitObus(binary_ptr message) {
117117
**/
118118

119119
std::vector<binary_ptr> AV1RtpPacketizer::packetizeObu(binary_ptr message,
120-
uint16_t maximumFragmentSize) {
120+
uint16_t maxFragmentSize) {
121121

122122
std::vector<shared_ptr<binary>> payloads{};
123123
size_t messageIndex = 0;
@@ -144,7 +144,7 @@ std::vector<binary_ptr> AV1RtpPacketizer::packetizeObu(binary_ptr message,
144144
}
145145

146146
auto payload = std::make_shared<binary>(
147-
std::min(size_t(maximumFragmentSize), messageRemaining + metadataSize));
147+
std::min(size_t(maxFragmentSize), messageRemaining + metadataSize));
148148
auto payloadOffset = payloadHeaderSize;
149149

150150
payload->at(0) = byte(obuCount) << wBitshift;
@@ -187,8 +187,8 @@ std::vector<binary_ptr> AV1RtpPacketizer::packetizeObu(binary_ptr message,
187187

188188
AV1RtpPacketizer::AV1RtpPacketizer(AV1RtpPacketizer::Packetization packetization,
189189
shared_ptr<RtpPacketizationConfig> rtpConfig,
190-
uint16_t maximumFragmentSize)
191-
: RtpPacketizer(rtpConfig), maximumFragmentSize(maximumFragmentSize),
190+
uint16_t maxFragmentSize)
191+
: RtpPacketizer(rtpConfig), maxFragmentSize(maxFragmentSize),
192192
packetization(packetization) {}
193193

194194
void AV1RtpPacketizer::outgoing(message_vector &messages,
@@ -204,7 +204,7 @@ void AV1RtpPacketizer::outgoing(message_vector &messages,
204204

205205
std::vector<binary_ptr> fragments;
206206
for (auto obu : obus) {
207-
auto p = packetizeObu(obu, maximumFragmentSize);
207+
auto p = packetizeObu(obu, maxFragmentSize);
208208
fragments.insert(fragments.end(), p.begin(), p.end());
209209
}
210210

‎src/capi.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -1220,7 +1220,7 @@ int rtcSetH264Packetizer(int tr, const rtcPacketizerInit *init) {
12201220
// create packetizer
12211221
auto nalSeparator = init ? init->nalSeparator : RTC_NAL_SEPARATOR_LENGTH;
12221222
auto maxFragmentSize = init && init->maxFragmentSize ? init->maxFragmentSize
1223-
: RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE;
1223+
: RTC_DEFAULT_MAX_FRAGMENT_SIZE;
12241224
auto packetizer = std::make_shared<H264RtpPacketizer>(
12251225
static_cast<rtc::NalUnit::Separator>(nalSeparator), rtpConfig, maxFragmentSize);
12261226
track->setMediaHandler(packetizer);
@@ -1236,7 +1236,7 @@ int rtcSetH265Packetizer(int tr, const rtcPacketizerInit *init) {
12361236
// create packetizer
12371237
auto nalSeparator = init ? init->nalSeparator : RTC_NAL_SEPARATOR_LENGTH;
12381238
auto maxFragmentSize = init && init->maxFragmentSize ? init->maxFragmentSize
1239-
: RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE;
1239+
: RTC_DEFAULT_MAX_FRAGMENT_SIZE;
12401240
auto packetizer = std::make_shared<H265RtpPacketizer>(
12411241
static_cast<rtc::NalUnit::Separator>(nalSeparator), rtpConfig, maxFragmentSize);
12421242
track->setMediaHandler(packetizer);
@@ -1251,7 +1251,7 @@ int rtcSetAV1Packetizer(int tr, const rtcPacketizerInit *init) {
12511251
auto rtpConfig = createRtpPacketizationConfig(init);
12521252
// create packetizer
12531253
auto maxFragmentSize = init && init->maxFragmentSize ? init->maxFragmentSize
1254-
: RTC_DEFAULT_MAXIMUM_FRAGMENT_SIZE;
1254+
: RTC_DEFAULT_MAX_FRAGMENT_SIZE;
12551255
auto packetization = init->obuPacketization == RTC_OBU_PACKETIZED_TEMPORAL_UNIT
12561256
? AV1RtpPacketizer::Packetization::TemporalUnit
12571257
: AV1RtpPacketizer::Packetization::Obu;

‎src/h264rtppacketizer.cpp

+5-5
Original file line numberDiff line numberDiff line change
@@ -81,20 +81,20 @@ shared_ptr<NalUnits> H264RtpPacketizer::splitMessage(binary_ptr message) {
8181
}
8282

8383
H264RtpPacketizer::H264RtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig,
84-
uint16_t maximumFragmentSize)
85-
: RtpPacketizer(std::move(rtpConfig)), maximumFragmentSize(maximumFragmentSize),
84+
uint16_t maxFragmentSize)
85+
: RtpPacketizer(std::move(rtpConfig)), maxFragmentSize(maxFragmentSize),
8686
separator(Separator::Length) {}
8787

8888
H264RtpPacketizer::H264RtpPacketizer(Separator separator,
8989
shared_ptr<RtpPacketizationConfig> rtpConfig,
90-
uint16_t maximumFragmentSize)
91-
: RtpPacketizer(rtpConfig), maximumFragmentSize(maximumFragmentSize), separator(separator) {}
90+
uint16_t maxFragmentSize)
91+
: RtpPacketizer(rtpConfig), maxFragmentSize(maxFragmentSize), separator(separator) {}
9292

9393
void H264RtpPacketizer::outgoing(message_vector &messages, [[maybe_unused]] const message_callback &send) {
9494
message_vector result;
9595
for(const auto &message : messages) {
9696
auto nalus = splitMessage(message);
97-
auto fragments = nalus->generateFragments(maximumFragmentSize);
97+
auto fragments = nalus->generateFragments(maxFragmentSize);
9898
if (fragments.size() == 0)
9999
continue;
100100

‎src/h265nalunit.cpp

+13-13
Original file line numberDiff line numberDiff line change
@@ -29,13 +29,13 @@ H265NalUnitFragment::H265NalUnitFragment(FragmentType type, bool forbiddenBit, u
2929
}
3030

3131
std::vector<shared_ptr<H265NalUnitFragment>>
32-
H265NalUnitFragment::fragmentsFrom(shared_ptr<H265NalUnit> nalu, uint16_t maximumFragmentSize) {
33-
assert(nalu->size() > maximumFragmentSize);
34-
auto fragments_count = ceil(double(nalu->size()) / maximumFragmentSize);
35-
maximumFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
32+
H265NalUnitFragment::fragmentsFrom(shared_ptr<H265NalUnit> nalu, uint16_t maxFragmentSize) {
33+
assert(nalu->size() > maxFragmentSize);
34+
auto fragments_count = ceil(double(nalu->size()) / maxFragmentSize);
35+
maxFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
3636

3737
// 3 bytes for FU indicator and FU header
38-
maximumFragmentSize -= (H265_NAL_HEADER_SIZE + H265_FU_HEADER_SIZE);
38+
maxFragmentSize -= (H265_NAL_HEADER_SIZE + H265_FU_HEADER_SIZE);
3939
auto f = nalu->forbiddenBit();
4040
uint8_t nuhLayerId = nalu->nuhLayerId() & 0x3F; // 6 bits
4141
uint8_t nuhTempIdPlus1 = nalu->nuhTempIdPlus1() & 0x7; // 3 bits
@@ -48,19 +48,19 @@ H265NalUnitFragment::fragmentsFrom(shared_ptr<H265NalUnit> nalu, uint16_t maximu
4848
FragmentType fragmentType;
4949
if (offset == 0) {
5050
fragmentType = FragmentType::Start;
51-
} else if (offset + maximumFragmentSize < payload.size()) {
51+
} else if (offset + maxFragmentSize < payload.size()) {
5252
fragmentType = FragmentType::Middle;
5353
} else {
54-
if (offset + maximumFragmentSize > payload.size()) {
55-
maximumFragmentSize = uint16_t(payload.size() - offset);
54+
if (offset + maxFragmentSize > payload.size()) {
55+
maxFragmentSize = uint16_t(payload.size() - offset);
5656
}
5757
fragmentType = FragmentType::End;
5858
}
59-
fragmentData = {payload.begin() + offset, payload.begin() + offset + maximumFragmentSize};
59+
fragmentData = {payload.begin() + offset, payload.begin() + offset + maxFragmentSize};
6060
auto fragment = std::make_shared<H265NalUnitFragment>(
6161
fragmentType, f, nuhLayerId, nuhTempIdPlus1, naluType, fragmentData);
6262
result.push_back(fragment);
63-
offset += maximumFragmentSize;
63+
offset += maxFragmentSize;
6464
}
6565
return result;
6666
}
@@ -81,12 +81,12 @@ void H265NalUnitFragment::setFragmentType(FragmentType type) {
8181
}
8282
}
8383

84-
std::vector<shared_ptr<binary>> H265NalUnits::generateFragments(uint16_t maximumFragmentSize) {
84+
std::vector<shared_ptr<binary>> H265NalUnits::generateFragments(uint16_t maxFragmentSize) {
8585
vector<shared_ptr<binary>> result{};
8686
for (auto nalu : *this) {
87-
if (nalu->size() > maximumFragmentSize) {
87+
if (nalu->size() > maxFragmentSize) {
8888
std::vector<shared_ptr<H265NalUnitFragment>> fragments =
89-
H265NalUnitFragment::fragmentsFrom(nalu, maximumFragmentSize);
89+
H265NalUnitFragment::fragmentsFrom(nalu, maxFragmentSize);
9090
result.insert(result.end(), fragments.begin(), fragments.end());
9191
} else {
9292
result.push_back(nalu);

‎src/h265rtppacketizer.cpp

+5-5
Original file line numberDiff line numberDiff line change
@@ -81,21 +81,21 @@ shared_ptr<H265NalUnits> H265RtpPacketizer::splitMessage(binary_ptr message) {
8181
}
8282

8383
H265RtpPacketizer::H265RtpPacketizer(shared_ptr<RtpPacketizationConfig> rtpConfig,
84-
uint16_t maximumFragmentSize)
85-
: RtpPacketizer(std::move(rtpConfig)), maximumFragmentSize(maximumFragmentSize),
84+
uint16_t maxFragmentSize)
85+
: RtpPacketizer(std::move(rtpConfig)), maxFragmentSize(maxFragmentSize),
8686
separator(NalUnit::Separator::Length) {}
8787

8888
H265RtpPacketizer::H265RtpPacketizer(NalUnit::Separator separator,
8989
shared_ptr<RtpPacketizationConfig> rtpConfig,
90-
uint16_t maximumFragmentSize)
91-
: RtpPacketizer(std::move(rtpConfig)), maximumFragmentSize(maximumFragmentSize),
90+
uint16_t maxFragmentSize)
91+
: RtpPacketizer(std::move(rtpConfig)), maxFragmentSize(maxFragmentSize),
9292
separator(separator) {}
9393

9494
void H265RtpPacketizer::outgoing(message_vector &messages, [[maybe_unused]] const message_callback &send) {
9595
message_vector result;
9696
for (const auto &message : messages) {
9797
auto nalus = splitMessage(message);
98-
auto fragments = nalus->generateFragments(maximumFragmentSize);
98+
auto fragments = nalus->generateFragments(maxFragmentSize);
9999
if (fragments.size() == 0)
100100
continue;
101101

‎src/nalunit.cpp

+13-13
Original file line numberDiff line numberDiff line change
@@ -28,13 +28,13 @@ NalUnitFragmentA::NalUnitFragmentA(FragmentType type, bool forbiddenBit, uint8_t
2828
}
2929

3030
std::vector<shared_ptr<NalUnitFragmentA>>
31-
NalUnitFragmentA::fragmentsFrom(shared_ptr<NalUnit> nalu, uint16_t maximumFragmentSize) {
32-
assert(nalu->size() > maximumFragmentSize);
33-
auto fragments_count = ceil(double(nalu->size()) / maximumFragmentSize);
34-
maximumFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
31+
NalUnitFragmentA::fragmentsFrom(shared_ptr<NalUnit> nalu, uint16_t maxFragmentSize) {
32+
assert(nalu->size() > maxFragmentSize);
33+
auto fragments_count = ceil(double(nalu->size()) / maxFragmentSize);
34+
maxFragmentSize = uint16_t(int(ceil(nalu->size() / fragments_count)));
3535

3636
// 2 bytes for FU indicator and FU header
37-
maximumFragmentSize -= 2;
37+
maxFragmentSize -= 2;
3838
auto f = nalu->forbiddenBit();
3939
uint8_t nri = nalu->nri() & 0x03;
4040
uint8_t naluType = nalu->unitType() & 0x1F;
@@ -46,19 +46,19 @@ NalUnitFragmentA::fragmentsFrom(shared_ptr<NalUnit> nalu, uint16_t maximumFragme
4646
FragmentType fragmentType;
4747
if (offset == 0) {
4848
fragmentType = FragmentType::Start;
49-
} else if (offset + maximumFragmentSize < payload.size()) {
49+
} else if (offset + maxFragmentSize < payload.size()) {
5050
fragmentType = FragmentType::Middle;
5151
} else {
52-
if (offset + maximumFragmentSize > payload.size()) {
53-
maximumFragmentSize = uint16_t(payload.size() - offset);
52+
if (offset + maxFragmentSize > payload.size()) {
53+
maxFragmentSize = uint16_t(payload.size() - offset);
5454
}
5555
fragmentType = FragmentType::End;
5656
}
57-
fragmentData = {payload.begin() + offset, payload.begin() + offset + maximumFragmentSize};
57+
fragmentData = {payload.begin() + offset, payload.begin() + offset + maxFragmentSize};
5858
auto fragment =
5959
std::make_shared<NalUnitFragmentA>(fragmentType, f, nri, naluType, fragmentData);
6060
result.push_back(fragment);
61-
offset += maximumFragmentSize;
61+
offset += maxFragmentSize;
6262
}
6363
return result;
6464
}
@@ -80,12 +80,12 @@ void NalUnitFragmentA::setFragmentType(FragmentType type) {
8080
}
8181
}
8282

83-
std::vector<shared_ptr<binary>> NalUnits::generateFragments(uint16_t maximumFragmentSize) {
83+
std::vector<shared_ptr<binary>> NalUnits::generateFragments(uint16_t maxFragmentSize) {
8484
vector<shared_ptr<binary>> result{};
8585
for (auto nalu : *this) {
86-
if (nalu->size() > maximumFragmentSize) {
86+
if (nalu->size() > maxFragmentSize) {
8787
std::vector<shared_ptr<NalUnitFragmentA>> fragments =
88-
NalUnitFragmentA::fragmentsFrom(nalu, maximumFragmentSize);
88+
NalUnitFragmentA::fragmentsFrom(nalu, maxFragmentSize);
8989
result.insert(result.end(), fragments.begin(), fragments.end());
9090
} else {
9191
result.push_back(nalu);

0 commit comments

Comments
 (0)