Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-09 03:48:44 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move all udt header constants to Constant.h

Browse source
This commit is contained in:
Atlante45 2016-02-19 11:14:05 -08:00
parent 3d7d812044
commit 4605cf5087
4 changed files with 63 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
libraries/networking/src/udt/Constants.h
View file

@ -26,10 +26,63 @@ namespace udt {
static const int UDP_SEND_BUFFER_SIZE_BYTES = 1048576; static const int UDP_SEND_BUFFER_SIZE_BYTES = 1048576;
static const int UDP_RECEIVE_BUFFER_SIZE_BYTES = 1048576; static const int UDP_RECEIVE_BUFFER_SIZE_BYTES = 1048576;
static const int DEFAULT_SYN_INTERVAL_USECS = 10 * 1000; static const int DEFAULT_SYN_INTERVAL_USECS = 10 * 1000;
static const int SEQUENCE_NUMBER_BITS = sizeof(SequenceNumber) * 8;
static const int MESSAGE_LINE_NUMBER_BITS = 32; // Header constants
static const int MESSAGE_NUMBER_BITS = 30;
static const uint32_t CONTROL_BIT_MASK = uint32_t(1) << (SEQUENCE_NUMBER_BITS - 1); // Bit sizes (in order)
static const int CONTROL_BIT_SIZE = 1;
static const int RELIABILITY_BIT_SIZE = 1;
static const int MESSAGE_BIT_SIZE = 1;
static const int OBFUSCATION_LEVEL_SIZE = 2;
static const int SEQUENCE_NUMBER_SIZE= 27;
static const int PACKET_POSITION_SIZE = 2;
static const int MESSAGE_NUMBER_SIZE = 30;
static const int MESSAGE_PART_NUMBER_SIZE = 32;
// Offsets
static const int SEQUENCE_NUMBER_OFFSET = 0;
static const int OBFUSCATION_LEVEL_OFFSET = SEQUENCE_NUMBER_OFFSET + SEQUENCE_NUMBER_SIZE;
static const int MESSAGE_BIT_OFFSET = OBFUSCATION_LEVEL_OFFSET + OBFUSCATION_LEVEL_SIZE;
static const int RELIABILITY_BIT_OFFSET = MESSAGE_BIT_OFFSET + MESSAGE_BIT_SIZE;
static const int CONTROL_BIT_OFFSET = RELIABILITY_BIT_OFFSET + RELIABILITY_BIT_SIZE;
static const int MESSAGE_NUMBER_OFFSET = 0;
static const int PACKET_POSITION_OFFSET = MESSAGE_NUMBER_OFFSET + MESSAGE_NUMBER_SIZE;
static const int MESSAGE_PART_NUMBER_OFFSET = 0;
// Masks
static const uint32_t CONTROL_BIT_MASK = uint32_t(0b1) << CONTROL_BIT_OFFSET;
static const uint32_t RELIABILITY_BIT_MASK = uint32_t(0b1) << RELIABILITY_BIT_OFFSET;
static const uint32_t MESSAGE_BIT_MASK = uint32_t(0b1) << MESSAGE_BIT_OFFSET;
static const uint32_t OBFUSCATION_LEVEL_MASK = uint32_t(0b11) << OBFUSCATION_LEVEL_OFFSET;
static const uint32_t BIT_FIELD_MASK = CONTROL_BIT_MASK | RELIABILITY_BIT_MASK | MESSAGE_BIT_MASK | OBFUSCATION_LEVEL_MASK;
static const uint32_t SEQUENCE_NUMBER_MASK = ~BIT_FIELD_MASK;
static const uint32_t PACKET_POSITION_MASK = uint32_t(0b11) << PACKET_POSITION_OFFSET;
static const uint32_t MESSAGE_NUMBER_MASK = ~PACKET_POSITION_MASK;
static const uint32_t MESSAGE_PART_NUMBER_MASK = ~uint32_t(0);
// Static checks
static_assert(CONTROL_BIT_SIZE + RELIABILITY_BIT_SIZE + MESSAGE_BIT_SIZE +
OBFUSCATION_LEVEL_SIZE + SEQUENCE_NUMBER_SIZE == 32, "Sequence number line size incorrect");
static_assert(PACKET_POSITION_SIZE + MESSAGE_NUMBER_SIZE == 32, "Message number line size incorrect");
static_assert(MESSAGE_PART_NUMBER_SIZE == 32, "Message part number line size incorrect");
static_assert(CONTROL_BIT_MASK == 0b10000000000000000000000000000000, "CONTROL_BIT_MASK incorrect");
static_assert(RELIABILITY_BIT_MASK == 0b01000000000000000000000000000000, "RELIABILITY_BIT_MASK incorrect");
static_assert(MESSAGE_BIT_MASK == 0b00100000000000000000000000000000, "MESSAGE_BIT_MASK incorrect");
static_assert(OBFUSCATION_LEVEL_MASK == 0b00011000000000000000000000000000, "OBFUSCATION_LEVEL_MASK incorrect");
static_assert(BIT_FIELD_MASK == 0b11111000000000000000000000000000, "BIT_FIELD_MASK incorrect");
static_assert(SEQUENCE_NUMBER_MASK == 0b00000111111111111111111111111111, "SEQUENCE_NUMBER_MASK incorrect");
static_assert(PACKET_POSITION_MASK == 0b11000000000000000000000000000000, "PACKET_POSITION_MASK incorrect");
static_assert(MESSAGE_NUMBER_MASK == 0b00111111111111111111111111111111, "MESSAGE_NUMBER_MASK incorrect");
static_assert(MESSAGE_PART_NUMBER_MASK == 0b11111111111111111111111111111111, "MESSAGE_PART_NUMBER_MASK incorrect");
} }
#endif // hifi_udt_Constants_h #endif // hifi_udt_Constants_h

17
libraries/networking/src/udt/Packet.cpp
View file

@ -120,20 +120,11 @@ void Packet::writeMessageNumber(MessageNumber messageNumber, PacketPosition posi
} }
void Packet::writeSequenceNumber(SequenceNumber sequenceNumber, ObfuscationLevel level) const { void Packet::writeSequenceNumber(SequenceNumber sequenceNumber, ObfuscationLevel level) const {
_obfuscationLevel = level;
_sequenceNumber = sequenceNumber; _sequenceNumber = sequenceNumber;
_obfuscationLevel = level;
writeHeader(); writeHeader();
} }
static const uint32_t RELIABILITY_BIT_MASK = uint32_t(1) << (SEQUENCE_NUMBER_BITS - 2);
static const uint32_t MESSAGE_BIT_MASK = uint32_t(1) << (SEQUENCE_NUMBER_BITS - 3);
static const uint32_t OBFUSCATION_LEVEL_MASK = uint32_t(0x03) << (SEQUENCE_NUMBER_BITS - 5);
static const uint32_t BIT_FIELD_MASK = CONTROL_BIT_MASK | RELIABILITY_BIT_MASK | MESSAGE_BIT_MASK | OBFUSCATION_LEVEL_MASK;
static const uint8_t PACKET_POSITION_OFFSET = 30;
static const uint32_t PACKET_POSITION_MASK = uint32_t(0x03) << PACKET_POSITION_OFFSET;
static const uint32_t MESSAGE_NUMBER_MASK = ~PACKET_POSITION_MASK;
void Packet::readHeader() const { void Packet::readHeader() const {
SequenceNumberAndBitField* seqNumBitField = reinterpret_cast<SequenceNumberAndBitField*>(_packet.get()); SequenceNumberAndBitField* seqNumBitField = reinterpret_cast<SequenceNumberAndBitField*>(_packet.get());
@ -141,8 +132,8 @@ void Packet::readHeader() const {
_isReliable = (bool) (*seqNumBitField & RELIABILITY_BIT_MASK); // Only keep reliability bit _isReliable = (bool) (*seqNumBitField & RELIABILITY_BIT_MASK); // Only keep reliability bit
_isPartOfMessage = (bool) (*seqNumBitField & MESSAGE_BIT_MASK); // Only keep message bit _isPartOfMessage = (bool) (*seqNumBitField & MESSAGE_BIT_MASK); // Only keep message bit
_obfuscationLevel = (ObfuscationLevel)((*seqNumBitField & OBFUSCATION_LEVEL_MASK) >> (SEQUENCE_NUMBER_BITS - 5)); _obfuscationLevel = (ObfuscationLevel)((*seqNumBitField & OBFUSCATION_LEVEL_MASK) >> OBFUSCATION_LEVEL_OFFSET);
_sequenceNumber = SequenceNumber{ *seqNumBitField & ~BIT_FIELD_MASK }; // Remove the bit field _sequenceNumber = SequenceNumber{ *seqNumBitField & SEQUENCE_NUMBER_MASK }; // Remove the bit field
if (_isPartOfMessage) { if (_isPartOfMessage) {
MessageNumberAndBitField* messageNumberAndBitField = seqNumBitField + 1; MessageNumberAndBitField* messageNumberAndBitField = seqNumBitField + 1;
@ -168,7 +159,7 @@ void Packet::writeHeader() const {
} }
if (_obfuscationLevel != NoObfuscation) { if (_obfuscationLevel != NoObfuscation) {
*seqNumBitField |= (_obfuscationLevel << (SEQUENCE_NUMBER_BITS - 5)); *seqNumBitField |= (_obfuscationLevel << OBFUSCATION_LEVEL_OFFSET);
} }
if (_isPartOfMessage) { if (_isPartOfMessage) {

2
libraries/networking/src/udt/Packet.h
View file

@ -65,7 +65,7 @@ public:
NoObfuscation = 0x0, // 00 NoObfuscation = 0x0, // 00
ObfuscationL1 = 0x1, // 01 ObfuscationL1 = 0x1, // 01
ObfuscationL2 = 0x2, // 10 ObfuscationL2 = 0x2, // 10
ObfuscationL3 = 0x3, // 01 ObfuscationL3 = 0x3, // 11
}; };
static std::unique_ptr<Packet> create(qint64 size = -1, bool isReliable = false, bool isPartOfMessage = false); static std::unique_ptr<Packet> create(qint64 size = -1, bool isReliable = false, bool isPartOfMessage = false);

2
libraries/networking/src/udt/PacketQueue.cpp
View file

@ -16,7 +16,7 @@
using namespace udt; using namespace udt;
MessageNumber PacketQueue::getNextMessageNumber() { MessageNumber PacketQueue::getNextMessageNumber() {
static const MessageNumber MAX_MESSAGE_NUMBER = MessageNumber(1) << MESSAGE_NUMBER_BITS; static const MessageNumber MAX_MESSAGE_NUMBER = MessageNumber(1) << MESSAGE_NUMBER_SIZE;
_currentMessageNumber = (_currentMessageNumber + 1) % MAX_MESSAGE_NUMBER; _currentMessageNumber = (_currentMessageNumber + 1) % MAX_MESSAGE_NUMBER;
return _currentMessageNumber; return _currentMessageNumber;
} }