diff --git a/srtcore/buffer_snd.cpp b/srtcore/buffer_snd.cpp
index 3aa81042e..ef1bc498c 100644
--- a/srtcore/buffer_snd.cpp
+++ b/srtcore/buffer_snd.cpp
@@ -317,7 +317,7 @@ int CSndBuffer::readData(CPacket& w_packet, steady_clock::time_point& w_srctime,
         w_packet.m_pcData = m_pCurrBlock->m_pcData;
         readlen = m_pCurrBlock->m_iLength;
         w_packet.setLength(readlen, m_iBlockLen);
-        w_packet.m_iSeqNo = m_pCurrBlock->m_iSeqNo;
+        w_packet.set_seqno(m_pCurrBlock->m_iSeqNo);
 
         // 1. On submission (addBuffer), the KK flag is set to EK_NOENC (0).
         // 2. The readData() is called to get the original (unique) payload not ever sent yet.
@@ -343,7 +343,7 @@ int CSndBuffer::readData(CPacket& w_packet, steady_clock::time_point& w_srctime,
         }
 
         Block* p = m_pCurrBlock;
-        w_packet.m_iMsgNo = m_pCurrBlock->m_iMsgNoBitset;
+        w_packet.set_msgflags(m_pCurrBlock->m_iMsgNoBitset);
         w_srctime = m_pCurrBlock->m_tsOriginTime;
         m_pCurrBlock = m_pCurrBlock->m_pNext;
 
@@ -358,7 +358,7 @@ int CSndBuffer::readData(CPacket& w_packet, steady_clock::time_point& w_srctime,
 
         HLOGC(bslog.Debug, log << CONID() << "CSndBuffer: picked up packet to send: size=" << readlen
                 << " #" << w_packet.getMsgSeq()
-                << " %" << w_packet.m_iSeqNo
+                << " %" << w_packet.seqno()
                 << " !" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
 
         break;
@@ -449,7 +449,7 @@ int CSndBuffer::readData(const int offset, CPacket& w_packet, steady_clock::time
 
     // This is rexmit request, so the packet should have the sequence number
     // already set when it was once sent uniquely.
-    SRT_ASSERT(p->m_iSeqNo == w_packet.m_iSeqNo);
+    SRT_ASSERT(p->m_iSeqNo == w_packet.seqno());
 
     // Check if the block that is the next candidate to send (m_pCurrBlock pointing) is stale.
 
@@ -493,8 +493,8 @@ int CSndBuffer::readData(const int offset, CPacket& w_packet, steady_clock::time
         // to simply take the sequence number from the block. But this is a new
         // feature and should be only used after refax for the sender buffer to
         // make it manage the sequence numbers inside, instead of by CUDT::m_iSndLastDataAck.
-        w_drop.seqno[DropRange::BEGIN] = w_packet.m_iSeqNo;
-        w_drop.seqno[DropRange::END] = CSeqNo::incseq(w_packet.m_iSeqNo, msglen - 1);
+        w_drop.seqno[DropRange::BEGIN] = w_packet.seqno();
+        w_drop.seqno[DropRange::END] = CSeqNo::incseq(w_packet.seqno(), msglen - 1);
 
         // Note the rules: here `p` is pointing to the first block AFTER the
         // message to be dropped, so the end sequence should be one behind
@@ -515,7 +515,7 @@ int CSndBuffer::readData(const int offset, CPacket& w_packet, steady_clock::time
     // encrypted, and with all ENC flags already set. So, the first call to send
     // the packet originally (the other overload of this function) must set these
     // flags.
-    w_packet.m_iMsgNo = p->m_iMsgNoBitset;
+    w_packet.set_msgflags(p->m_iMsgNoBitset);
     w_srctime = p->m_tsOriginTime;
 
     // This function is called when packet retransmission is triggered.
@@ -523,7 +523,7 @@ int CSndBuffer::readData(const int offset, CPacket& w_packet, steady_clock::time
     p->m_tsRexmitTime = steady_clock::now();
 
     HLOGC(qslog.Debug,
-          log << CONID() << "CSndBuffer: getting packet %" << p->m_iSeqNo << " as per %" << w_packet.m_iSeqNo
+          log << CONID() << "CSndBuffer: getting packet %" << p->m_iSeqNo << " as per %" << w_packet.seqno()
               << " size=" << readlen << " to send [REXMIT]");
 
     return readlen;
diff --git a/srtcore/channel.cpp b/srtcore/channel.cpp
index 0b448d681..16ccc8c1b 100644
--- a/srtcore/channel.cpp
+++ b/srtcore/channel.cpp
@@ -683,8 +683,8 @@ int srt::CChannel::sendto(const sockaddr_any& addr, CPacket& packet, const socka
 #endif
 
     LOGC(kslog.Debug,
-         log << "CChannel::sendto: SENDING NOW DST=" << addr.str() << " target=@" << packet.m_iID
-             << " size=" << packet.getLength() << " pkt.ts=" << packet.m_iTimeStamp
+         log << "CChannel::sendto: SENDING NOW DST=" << addr.str() << " target=@" << packet.id()
+             << " size=" << packet.getLength() << " pkt.ts=" << packet.timestamp()
              << dsrc.str() << " " << packet.Info());
 #endif
 
diff --git a/srtcore/core.cpp b/srtcore/core.cpp
index dcb264993..f595e303d 100644
--- a/srtcore/core.cpp
+++ b/srtcore/core.cpp
@@ -1982,7 +1982,7 @@ bool srt::CUDT::processSrtMsg(const CPacket *ctrlpkt)
     uint32_t *srtdata = (uint32_t *)ctrlpkt->m_pcData;
     size_t    len     = ctrlpkt->getLength();
     int       etype   = ctrlpkt->getExtendedType();
-    uint32_t  ts      = ctrlpkt->m_iTimeStamp;
+    uint32_t  ts      = ctrlpkt->timestamp();
 
     int res = SRT_CMD_NONE;
 
@@ -2513,7 +2513,7 @@ bool srt::CUDT::interpretSrtHandshake(const CHandShake& hs,
                     return false; // don't interpret
                 }
 
-                int rescmd = processSrtMsg_HSREQ(begin + 1, bytelen, hspkt.m_iTimeStamp, HS_VERSION_SRT1);
+                int rescmd = processSrtMsg_HSREQ(begin + 1, bytelen, hspkt.timestamp(), HS_VERSION_SRT1);
                 // Interpreted? Then it should be responded with SRT_CMD_HSRSP.
                 if (rescmd != SRT_CMD_HSRSP)
                 {
@@ -2540,7 +2540,7 @@ bool srt::CUDT::interpretSrtHandshake(const CHandShake& hs,
                     return false; // don't interpret
                 }
 
-                int rescmd = processSrtMsg_HSRSP(begin + 1, bytelen, hspkt.m_iTimeStamp, HS_VERSION_SRT1);
+                int rescmd = processSrtMsg_HSRSP(begin + 1, bytelen, hspkt.timestamp(), HS_VERSION_SRT1);
                 // Interpreted? Then it should be responded with SRT_CMD_NONE.
                 // (nothing to be responded for HSRSP, unless there was some kinda problem)
                 if (rescmd != SRT_CMD_NONE)
@@ -3572,7 +3572,7 @@ void srt::CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
     // control of methods.)
 
     // ID = 0, connection request
-    reqpkt.m_iID = 0;
+    reqpkt.set_id(0);
 
     size_t hs_size = m_iMaxSRTPayloadSize;
     m_ConnReq.store_to((reqpkt.m_pcData), (hs_size));
@@ -3587,7 +3587,7 @@ void srt::CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
     setPacketTS(reqpkt, tnow);
 
     HLOGC(cnlog.Debug,
-          log << CONID() << "CUDT::startConnect: REQ-TIME set HIGH (TimeStamp: " << reqpkt.m_iTimeStamp
+          log << CONID() << "CUDT::startConnect: REQ-TIME set HIGH (TimeStamp: " << reqpkt.timestamp()
               << "). SENDING HS: " << m_ConnReq.show());
 
     /*
@@ -3659,7 +3659,7 @@ void srt::CUDT::startConnect(const sockaddr_any& serv_addr, int32_t forced_isn)
                       << " > 250 ms). size=" << reqpkt.getLength());
 
             if (m_config.bRendezvous)
-                reqpkt.m_iID = m_ConnRes.m_iID;
+                reqpkt.set_id(m_ConnRes.m_iID);
 
 #if ENABLE_HEAVY_LOGGING
             {
@@ -3897,17 +3897,17 @@ bool srt::CUDT::processAsyncConnectRequest(EReadStatus         rst,
     // This should have got the original value returned from
     // processConnectResponse through processAsyncConnectResponse.
 
-    CPacket request;
-    request.setControl(UMSG_HANDSHAKE);
-    request.allocate(m_iMaxSRTPayloadSize);
+    CPacket reqpkt;
+    reqpkt.setControl(UMSG_HANDSHAKE);
+    reqpkt.allocate(m_iMaxSRTPayloadSize);
     const steady_clock::time_point now = steady_clock::now();
-    setPacketTS(request, now);
+    setPacketTS(reqpkt, now);
 
     HLOGC(cnlog.Debug,
           log << CONID() << "processAsyncConnectRequest: REQ-TIME: HIGH. Should prevent too quick responses.");
     m_tsLastReqTime = now;
     // ID = 0, connection request
-    request.m_iID = !m_config.bRendezvous ? 0 : m_ConnRes.m_iID;
+    reqpkt.set_id(!m_config.bRendezvous ? 0 : m_ConnRes.m_iID);
 
     bool status = true;
 
@@ -3918,7 +3918,7 @@ bool srt::CUDT::processAsyncConnectRequest(EReadStatus         rst,
     if (cst == CONN_RENDEZVOUS)
     {
         HLOGC(cnlog.Debug, log << CONID() << "processAsyncConnectRequest: passing to processRendezvous");
-        cst = processRendezvous(pResponse, serv_addr, rst, (request));
+        cst = processRendezvous(pResponse, serv_addr, rst, (reqpkt));
         if (cst == CONN_ACCEPT)
         {
             HLOGC(cnlog.Debug,
@@ -3938,7 +3938,7 @@ bool srt::CUDT::processAsyncConnectRequest(EReadStatus         rst,
             if (m_RejectReason == SRT_REJ_UNKNOWN)
                 m_RejectReason = SRT_REJ_ROGUE;
 
-            sendRendezvousRejection(serv_addr, (request));
+            sendRendezvousRejection(serv_addr, (reqpkt));
             status = false;
         }
     }
@@ -3955,8 +3955,8 @@ bool srt::CUDT::processAsyncConnectRequest(EReadStatus         rst,
     {
         // (this procedure will be also run for HSv4 rendezvous)
         HLOGC(cnlog.Debug,
-              log << CONID() << "processAsyncConnectRequest: serializing HS: buffer size=" << request.getLength());
-        if (!createSrtHandshake(SRT_CMD_HSREQ, SRT_CMD_KMREQ, 0, 0, (request), (m_ConnReq)))
+              log << CONID() << "processAsyncConnectRequest: serializing HS: buffer size=" << reqpkt.getLength());
+        if (!createSrtHandshake(SRT_CMD_HSREQ, SRT_CMD_KMREQ, 0, 0, (reqpkt), (m_ConnReq)))
         {
             // All 'false' returns from here are IPE-type, mostly "invalid argument" plus "all keys expired".
             LOGC(cnlog.Error,
@@ -3968,7 +3968,7 @@ bool srt::CUDT::processAsyncConnectRequest(EReadStatus         rst,
             HLOGC(cnlog.Debug,
                   log << CONID()
                       << "processAsyncConnectRequest: sending HS reqtype=" << RequestTypeStr(m_ConnReq.m_iReqType)
-                      << " to socket " << request.m_iID << " size=" << request.getLength());
+                      << " to socket " << reqpkt.id() << " size=" << reqpkt.getLength());
         }
     }
 
@@ -3978,16 +3978,16 @@ bool srt::CUDT::processAsyncConnectRequest(EReadStatus         rst,
         /* XXX Shouldn't it send a single response packet for the rejection?
         // Set the version to 0 as "handshake rejection" status and serialize it
         CHandShake zhs;
-        size_t size = request.getLength();
-        zhs.store_to((request.m_pcData), (size));
-        request.setLength(size);
+        size_t size = reqpkt.getLength();
+        zhs.store_to((reqpkt.m_pcData), (size));
+        reqpkt.setLength(size);
         */
     }
 
     HLOGC(cnlog.Debug,
           log << CONID() << "processAsyncConnectRequest: setting REQ-TIME HIGH, SENDING HS:" << m_ConnReq.show());
     m_tsLastReqTime = steady_clock::now();
-    m_pSndQueue->sendto(serv_addr, request, m_SourceAddr);
+    m_pSndQueue->sendto(serv_addr, reqpkt, m_SourceAddr);
     return status;
 }
 
@@ -5869,15 +5869,15 @@ void srt::CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any&
     size_t size = m_iMaxSRTPayloadSize;
     // Allocate the maximum possible memory for an SRT payload.
     // This is a maximum you can send once.
-    CPacket response;
-    response.setControl(UMSG_HANDSHAKE);
-    response.allocate(size);
+    CPacket rsppkt;
+    rsppkt.setControl(UMSG_HANDSHAKE);
+    rsppkt.allocate(size);
 
     // This will serialize the handshake according to its current form.
     HLOGC(cnlog.Debug,
           log << CONID()
               << "acceptAndRespond: creating CONCLUSION response (HSv5: with HSRSP/KMRSP) buffer size=" << size);
-    if (!createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP, kmdata, kmdatasize, (response), (w_hs)))
+    if (!createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP, kmdata, kmdatasize, (rsppkt), (w_hs)))
     {
         LOGC(cnlog.Error, log << CONID() << "acceptAndRespond: error creating handshake response");
         throw CUDTException(MJ_SETUP, MN_REJECTED, 0);
@@ -5891,10 +5891,10 @@ void srt::CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any&
         // To make sure what REALLY is being sent, parse back the handshake
         // data that have been just written into the buffer.
         CHandShake debughs;
-        debughs.load_from(response.m_pcData, response.getLength());
+        debughs.load_from(rsppkt.m_pcData, rsppkt.getLength());
         HLOGC(cnlog.Debug,
               log << CONID() << "acceptAndRespond: sending HS from agent @"
-                << debughs.m_iID << " to peer @" << response.m_iID
+                << debughs.m_iID << " to peer @" << rsppkt.id()
                 << "HS:" << debughs.show()
                 << " sourceIP=" << m_SourceAddr.str());
     }
@@ -5905,7 +5905,7 @@ void srt::CUDT::acceptAndRespond(const sockaddr_any& agent, const sockaddr_any&
     // When missed this message, the caller should not accept packets
     // coming as connected, but continue repeated handshake until finally
     // received the listener's handshake.
-    addressAndSend((response));
+    addressAndSend((rsppkt));
 }
 
 bool srt::CUDT::frequentLogAllowed(size_t logid, const time_point& tnow, std::string& w_why)
@@ -6151,7 +6151,7 @@ void srt::CUDT::checkSndKMRefresh()
 
 void srt::CUDT::addressAndSend(CPacket& w_pkt)
 {
-    w_pkt.m_iID        = m_PeerID;
+    w_pkt.set_id(m_PeerID);
     setPacketTS(w_pkt, steady_clock::now());
 
     // NOTE: w_pkt isn't modified in this call,
@@ -7874,7 +7874,7 @@ void srt::CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rp
 
     case UMSG_ACKACK: // 110 - Acknowledgement of Acknowledgement
         ctrlpkt.pack(pkttype, lparam);
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
@@ -7889,7 +7889,7 @@ void srt::CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rp
             size_t bytes = sizeof(*lossdata) * size;
             ctrlpkt.pack(pkttype, NULL, lossdata, bytes);
 
-            ctrlpkt.m_iID = m_PeerID;
+            ctrlpkt.set_id(m_PeerID);
             nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
             enterCS(m_StatsLock);
@@ -7910,7 +7910,7 @@ void srt::CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rp
             if (0 < losslen)
             {
                 ctrlpkt.pack(pkttype, NULL, data, losslen * 4);
-                ctrlpkt.m_iID = m_PeerID;
+                ctrlpkt.set_id(m_PeerID);
                 nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
                 enterCS(m_StatsLock);
@@ -7940,7 +7940,7 @@ void srt::CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rp
 
     case UMSG_CGWARNING: // 100 - Congestion Warning
         ctrlpkt.pack(pkttype);
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         m_tsLastWarningTime = steady_clock::now();
@@ -7949,14 +7949,14 @@ void srt::CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rp
 
     case UMSG_KEEPALIVE: // 001 - Keep-alive
         ctrlpkt.pack(pkttype);
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
     case UMSG_HANDSHAKE: // 000 - Handshake
         ctrlpkt.pack(pkttype, NULL, rparam, sizeof(CHandShake));
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
@@ -7965,21 +7965,21 @@ void srt::CUDT::sendCtrl(UDTMessageType pkttype, const int32_t* lparam, void* rp
         if (m_PeerID == 0) // Dont't send SHUTDOWN if we don't know peer ID.
             break;
         ctrlpkt.pack(pkttype);
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
     case UMSG_DROPREQ: // 111 - Msg drop request
         ctrlpkt.pack(pkttype, lparam, rparam, 8);
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
 
     case UMSG_PEERERROR: // 1000 - acknowledge the peer side a special error
         ctrlpkt.pack(pkttype, lparam);
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         nbsent        = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
 
         break;
@@ -8066,7 +8066,7 @@ int srt::CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
     {
         bufflock.unlock();
         ctrlpkt.pack(UMSG_ACK, NULL, &ack, size);
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         nbsent = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
         DebugAck(CONID() + "sendCtrl(lite): ", local_prevack, ack);
         return nbsent;
@@ -8270,7 +8270,7 @@ int srt::CUDT::sendCtrlAck(CPacket& ctrlpkt, int size)
             ctrlpkt.pack(UMSG_ACK, &m_iAckSeqNo, data, ACKD_FIELD_SIZE * ACKD_TOTAL_SIZE_SMALL);
         }
 
-        ctrlpkt.m_iID = m_PeerID;
+        ctrlpkt.set_id(m_PeerID);
         setPacketTS(ctrlpkt, steady_clock::now());
         nbsent = m_pSndQueue->sendto(m_PeerAddr, ctrlpkt, m_SourceAddr);
         DebugAck(CONID() + "sendCtrl(UMSG_ACK): ", local_prevack, ack);
@@ -8968,20 +8968,20 @@ void srt::CUDT::processCtrlHS(const CPacket& ctrlpkt)
             log << CONID() << "processCtrl: responding HS reqtype=" << RequestTypeStr(initdata.m_iReqType)
             << (have_hsreq ? " WITH SRT HS response extensions" : ""));
 
-        CPacket response;
-        response.setControl(UMSG_HANDSHAKE);
-        response.allocate(m_iMaxSRTPayloadSize);
+        CPacket rsppkt;
+        rsppkt.setControl(UMSG_HANDSHAKE);
+        rsppkt.allocate(m_iMaxSRTPayloadSize);
 
         // If createSrtHandshake failed, don't send anything. Actually it can only fail on IPE.
         // There is also no possible IPE condition in case of HSv4 - for this version it will always return true.
         enterCS(m_ConnectionLock);
-        bool create_ok = createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP, kmdata, kmdatasize, (response), (initdata));
+        bool create_ok = createSrtHandshake(SRT_CMD_HSRSP, SRT_CMD_KMRSP, kmdata, kmdatasize, (rsppkt), (initdata));
         leaveCS(m_ConnectionLock);
         if (create_ok)
         {
-            response.m_iID = m_PeerID;
-            setPacketTS(response, steady_clock::now());
-            const int nbsent = m_pSndQueue->sendto(m_PeerAddr, response, m_SourceAddr);
+            rsppkt.set_id(m_PeerID);
+            setPacketTS(rsppkt, steady_clock::now());
+            const int nbsent = m_pSndQueue->sendto(m_PeerAddr, rsppkt, m_SourceAddr);
             if (nbsent)
             {
                 m_tsLastSndTime.store(steady_clock::now());
@@ -9113,7 +9113,7 @@ void srt::CUDT::processCtrl(const CPacket &ctrlpkt)
 
     HLOGC(inlog.Debug,
           log << CONID() << "incoming UMSG:" << ctrlpkt.getType() << " ("
-              << MessageTypeStr(ctrlpkt.getType(), ctrlpkt.getExtendedType()) << ") socket=%" << ctrlpkt.m_iID);
+              << MessageTypeStr(ctrlpkt.getType(), ctrlpkt.getExtendedType()) << ") socket=%" << ctrlpkt.id());
 
     switch (ctrlpkt.getType())
     {
@@ -9288,37 +9288,44 @@ int srt::CUDT::packLostData(CPacket& w_packet)
     const steady_clock::time_point time_now = steady_clock::now();
     const steady_clock::time_point time_nak = time_now - microseconds_from(m_iSRTT - 4 * m_iRTTVar);
 
-    while ((w_packet.m_iSeqNo = m_pSndLossList->popLostSeq()) >= 0)
+    for (;;)
     {
+        w_packet.set_seqno(m_pSndLossList->popLostSeq());
+        if (w_packet.seqno() == SRT_SEQNO_NONE)
+            break;
+
         // XXX See the note above the m_iSndLastDataAck declaration in core.h
         // This is the place where the important sequence numbers for
         // sender buffer are actually managed by this field here.
-        const int offset = CSeqNo::seqoff(m_iSndLastDataAck, w_packet.m_iSeqNo);
+        const int offset = CSeqNo::seqoff(m_iSndLastDataAck, w_packet.seqno());
         if (offset < 0)
         {
             // XXX Likely that this will never be executed because if the upper
             // sequence is not in the sender buffer, then most likely the loss 
             // was completely ignored.
             LOGC(qrlog.Error,
-                 log << CONID() << "IPE/EPE: packLostData: LOST packet negative offset: seqoff(m_iSeqNo "
-                     << w_packet.m_iSeqNo << ", m_iSndLastDataAck " << m_iSndLastDataAck << ")=" << offset
-                     << ". Continue");
+                 log << CONID() << "IPE/EPE: packLostData: LOST packet negative offset: seqoff(seqno() "
+                     << w_packet.seqno() << ", m_iSndLastDataAck " << m_iSndLastDataAck << ")=" << offset
+                     << ". Continue, request DROP");
 
             // No matter whether this is right or not (maybe the attack case should be
             // considered, and some LOSSREPORT flood prevention), send the drop request
             // to the peer.
             int32_t seqpair[2] = {
-                w_packet.m_iSeqNo,
+                w_packet.seqno(),
                 CSeqNo::decseq(m_iSndLastDataAck)
             };
-            w_packet.m_iMsgNo = 0; // Message number is not known, setting all 32 bits to 0.
 
             HLOGC(qrlog.Debug,
-                  log << CONID() << "PEER reported LOSS not from the sending buffer - requesting DROP: msg="
-                      << MSGNO_SEQ::unwrap(w_packet.m_iMsgNo) << " SEQ:" << seqpair[0] << " - " << seqpair[1] << "("
+                  log << CONID() << "PEER reported LOSS not from the sending buffer - requesting DROP: #"
+                      << MSGNO_SEQ::unwrap(w_packet.msgflags()) << " SEQ:" << seqpair[0] << " - " << seqpair[1] << "("
                       << (-offset) << " packets)");
 
-            sendCtrl(UMSG_DROPREQ, &w_packet.m_iMsgNo, seqpair, sizeof(seqpair));
+            // See interpretation in processCtrlDropReq(). We don't know the message number,
+            // so we request that the drop be exclusively sequence number based.
+            int32_t msgno = SRT_MSGNO_CONTROL;
+
+            sendCtrl(UMSG_DROPREQ, &msgno, seqpair, sizeof(seqpair));
             continue;
         }
 
@@ -9328,7 +9335,7 @@ int srt::CUDT::packLostData(CPacket& w_packet)
             if (tsLastRexmit >= time_nak)
             {
                 HLOGC(qrlog.Debug, log << CONID() << "REXMIT: ignoring seqno "
-                    << w_packet.m_iSeqNo << ", last rexmit " << (is_zero(tsLastRexmit) ? "never" : FormatTime(tsLastRexmit))
+                    << w_packet.seqno() << ", last rexmit " << (is_zero(tsLastRexmit) ? "never" : FormatTime(tsLastRexmit))
                     << " RTT=" << m_iSRTT << " RTTVar=" << m_iRTTVar
                     << " now=" << FormatTime(time_now));
                 continue;
@@ -9380,7 +9387,7 @@ int srt::CUDT::packLostData(CPacket& w_packet)
         // So, set here the rexmit flag if the peer understands it.
         if (m_bPeerRexmitFlag)
         {
-            w_packet.m_iMsgNo |= PACKET_SND_REXMIT;
+            w_packet.set_msgflags(w_packet.msgflags() | PACKET_SND_REXMIT);
         }
         setDataPacketTS(w_packet, tsOrigin);
 
@@ -9485,7 +9492,7 @@ void srt::CUDT::setPacketTS(CPacket& p, const time_point& ts)
     enterCS(m_StatsLock);
     const time_point tsStart = m_stats.tsStartTime;
     leaveCS(m_StatsLock);
-    p.m_iTimeStamp = makeTS(ts, tsStart);
+    p.set_timestamp(makeTS(ts, tsStart));
 }
 
 void srt::CUDT::setDataPacketTS(CPacket& p, const time_point& ts)
@@ -9497,14 +9504,14 @@ void srt::CUDT::setDataPacketTS(CPacket& p, const time_point& ts)
     if (!m_bPeerTsbPd)
     {
         // If TSBPD is disabled, use the current time as the source (timestamp using the sending time).
-        p.m_iTimeStamp = makeTS(steady_clock::now(), tsStart);
+        p.set_timestamp(makeTS(steady_clock::now(), tsStart));
         return;
     }
 
     // TODO: Might be better for performance to ensure this condition is always false, and just use SRT_ASSERT here.
     if (ts < tsStart)
     {
-        p.m_iTimeStamp = makeTS(steady_clock::now(), tsStart);
+        p.set_timestamp(makeTS(steady_clock::now(), tsStart));
         LOGC(qslog.Warn,
             log << CONID() << "setPacketTS: reference time=" << FormatTime(ts)
             << " is in the past towards start time=" << FormatTime(tsStart)
@@ -9513,7 +9520,7 @@ void srt::CUDT::setDataPacketTS(CPacket& p, const time_point& ts)
     }
 
     // Use the provided source time for the timestamp.
-    p.m_iTimeStamp = makeTS(ts, tsStart);
+    p.set_timestamp(makeTS(ts, tsStart));
 }
 
 bool srt::CUDT::isRetransmissionAllowed(const time_point& tnow SRT_ATR_UNUSED)
@@ -9624,14 +9631,14 @@ bool srt::CUDT::packData(CPacket& w_packet, steady_clock::time_point& w_nexttime
         new_packet_packed = true;
 
         // every 16 (0xF) packets, a packet pair is sent
-        if ((w_packet.m_iSeqNo & PUMASK_SEQNO_PROBE) == 0)
+        if ((w_packet.seqno() & PUMASK_SEQNO_PROBE) == 0)
             probe = true;
 
         payload = (int) w_packet.getLength();
         IF_HEAVY_LOGGING(reason = "normal");
     }
 
-    w_packet.m_iID = m_PeerID; // Set the destination SRT socket ID.
+    w_packet.set_id(m_PeerID); // Set the destination SRT socket ID.
 
     if (new_packet_packed && m_PacketFilter)
     {
@@ -9641,7 +9648,7 @@ bool srt::CUDT::packData(CPacket& w_packet, steady_clock::time_point& w_nexttime
 
 #if ENABLE_HEAVY_LOGGING // Required because of referring to MessageFlagStr()
     HLOGC(qslog.Debug,
-          log << CONID() << "packData: " << reason << " packet seq=" << w_packet.m_iSeqNo << " (ACK=" << m_iSndLastAck
+          log << CONID() << "packData: " << reason << " packet seq=" << w_packet.seqno() << " (ACK=" << m_iSndLastAck
               << " ACKDATA=" << m_iSndLastDataAck << " MSG/FLAGS: " << w_packet.MessageFlagStr() << ")");
 #endif
 
@@ -9660,7 +9667,7 @@ bool srt::CUDT::packData(CPacket& w_packet, steady_clock::time_point& w_nexttime
     // Left untouched for historical reasons.
     // Might be possible that it was because of that this is send from
     // different thread than the rest of the signals.
-    // m_pSndTimeWindow->onPktSent(w_packet.m_iTimeStamp);
+    // m_pSndTimeWindow->onPktSent(w_packet.timestamp());
 
     enterCS(m_StatsLock);
     m_stats.sndr.sent.count(payload);
@@ -9760,7 +9767,7 @@ bool srt::CUDT::packUniqueData(CPacket& w_packet)
     // Fortunately the group itself isn't being accessed.
     if (m_parent->m_GroupOf)
     {
-        const int packetspan = CSeqNo::seqoff(current_sequence_number, w_packet.m_iSeqNo);
+        const int packetspan = CSeqNo::seqoff(current_sequence_number, w_packet.seqno());
         if (packetspan > 0)
         {
             // After increasing by 1, but being previously set as ISN-1, this should be == ISN,
@@ -9774,7 +9781,7 @@ bool srt::CUDT::packUniqueData(CPacket& w_packet)
                 // initialized from ISN just after connection.
                 LOGC(qslog.Note,
                      log << CONID() << "packUniqueData: Fixing EXTRACTION sequence " << current_sequence_number
-                         << " from SCHEDULING sequence " << w_packet.m_iSeqNo << " for the first packet: DIFF="
+                         << " from SCHEDULING sequence " << w_packet.seqno() << " for the first packet: DIFF="
                          << packetspan << " STAMP=" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
             }
             else
@@ -9782,7 +9789,7 @@ bool srt::CUDT::packUniqueData(CPacket& w_packet)
                 // There will be a serious data discrepancy between the agent and the peer.
                 LOGC(qslog.Error,
                      log << CONID() << "IPE: packUniqueData: Fixing EXTRACTION sequence " << current_sequence_number
-                         << " from SCHEDULING sequence " << w_packet.m_iSeqNo << " in the middle of transition: DIFF="
+                         << " from SCHEDULING sequence " << w_packet.seqno() << " in the middle of transition: DIFF="
                          << packetspan << " STAMP=" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
             }
 
@@ -9791,7 +9798,7 @@ bool srt::CUDT::packUniqueData(CPacket& w_packet)
             // Don't do it if the difference isn't positive or exceeds the threshold.
             int32_t seqpair[2];
             seqpair[0]             = current_sequence_number;
-            seqpair[1]             = CSeqNo::decseq(w_packet.m_iSeqNo);
+            seqpair[1]             = CSeqNo::decseq(w_packet.seqno());
             const int32_t no_msgno = 0;
             LOGC(qslog.Debug,
                  log << CONID() << "packUniqueData: Sending DROPREQ: SEQ: " << seqpair[0] << " - " << seqpair[1] << " ("
@@ -9803,16 +9810,16 @@ bool srt::CUDT::packUniqueData(CPacket& w_packet)
 
             // Override extraction sequence with scheduling sequence.
             ScopedLock ackguard(m_RecvAckLock);
-            m_iSndCurrSeqNo = w_packet.m_iSeqNo;
-            m_iSndLastAck     = w_packet.m_iSeqNo;
-            m_iSndLastDataAck = w_packet.m_iSeqNo;
-            m_iSndLastFullAck = w_packet.m_iSeqNo;
-            m_iSndLastAck2    = w_packet.m_iSeqNo;
+            m_iSndCurrSeqNo = w_packet.seqno();
+            m_iSndLastAck     = w_packet.seqno();
+            m_iSndLastDataAck = w_packet.seqno();
+            m_iSndLastFullAck = w_packet.seqno();
+            m_iSndLastAck2    = w_packet.seqno();
         }
         else if (packetspan < 0)
         {
             LOGC(qslog.Error,
-                 log << CONID() << "IPE: packData: SCHEDULING sequence " << w_packet.m_iSeqNo
+                 log << CONID() << "IPE: packData: SCHEDULING sequence " << w_packet.seqno()
                      << " is behind of EXTRACTION sequence " << current_sequence_number << ", dropping this packet: DIFF="
                      << packetspan << " STAMP=" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
             // XXX: Probably also change the socket state to broken?
@@ -9824,15 +9831,15 @@ bool srt::CUDT::packUniqueData(CPacket& w_packet)
     {
         HLOGC(qslog.Debug,
               log << CONID() << "packUniqueData: Applying EXTRACTION sequence " << current_sequence_number
-                  << " over SCHEDULING sequence " << w_packet.m_iSeqNo << " for socket not in group:"
-                  << " DIFF=" << CSeqNo::seqcmp(current_sequence_number, w_packet.m_iSeqNo)
+                  << " over SCHEDULING sequence " << w_packet.seqno() << " for socket not in group:"
+                  << " DIFF=" << CSeqNo::seqcmp(current_sequence_number, w_packet.seqno())
                   << " STAMP=" << BufferStamp(w_packet.m_pcData, w_packet.getLength()));
         // Do this always when not in a group.
-        w_packet.m_iSeqNo = current_sequence_number;
+        w_packet.set_seqno(current_sequence_number);
     }
 
     // Set missing fields before encrypting the packet, because those fields might be used for encryption.
-    w_packet.m_iID = m_PeerID; // Destination SRT Socket ID
+    w_packet.set_id(m_PeerID); // Destination SRT Socket ID
     setDataPacketTS(w_packet, tsOrigin);
 
     if (kflg != EK_NOENC)
@@ -9852,7 +9859,7 @@ bool srt::CUDT::packUniqueData(CPacket& w_packet)
     }
 
 #if SRT_DEBUG_TRACE_SND
-    g_snd_logger.state.iPktSeqno = w_packet.m_iSeqNo;
+    g_snd_logger.state.iPktSeqno = w_packet.seqno();
     g_snd_logger.state.isRetransmitted = w_packet.getRexmitFlag(); 
     g_snd_logger.trace();
 #endif
@@ -10021,7 +10028,7 @@ int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool&
 
         bool adding_successful = true;
 
-        const int32_t bufidx = CSeqNo::seqoff(bufseq, rpkt.m_iSeqNo);
+        const int32_t bufidx = CSeqNo::seqoff(bufseq, rpkt.seqno());
 
         IF_HEAVY_LOGGING(const char *exc_type = "EXPECTED");
 
@@ -10046,7 +10053,7 @@ int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool&
         // which never contains losses, so discarding this packet does not
         // discard a loss coverage, even if this were past ACK.
 
-        if (bufidx < 0 || CSeqNo::seqcmp(rpkt.m_iSeqNo, m_iRcvLastAck) < 0)
+        if (bufidx < 0 || CSeqNo::seqcmp(rpkt.seqno(), m_iRcvLastAck) < 0)
         {
             time_point pts = getPktTsbPdTime(NULL, rpkt);
 
@@ -10059,7 +10066,7 @@ int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool&
             m_stats.rcvr.recvdBelated.count(rpkt.getLength());
             leaveCS(m_StatsLock);
             HLOGC(qrlog.Debug,
-                    log << CONID() << "RECEIVED: %" << rpkt.m_iSeqNo << " bufidx=" << bufidx << " (BELATED/"
+                    log << CONID() << "RECEIVED: %" << rpkt.seqno() << " bufidx=" << bufidx << " (BELATED/"
                     << s_rexmitstat_str[pktrexmitflag] << ") with ACK %" << m_iRcvLastAck
                     << " FLAGS: " << rpkt.MessageFlagStr());
             continue;
@@ -10081,7 +10088,7 @@ int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool&
 
                 LOGC(qrlog.Error, log << CONID() <<
                         "SEQUENCE DISCREPANCY. BREAKING CONNECTION."
-                        " %" << rpkt.m_iSeqNo
+                        " %" << rpkt.seqno()
                         << " buffer=(%" << bufseq
                         << ":%" << m_iRcvCurrSeqNo                   // -1 = size to last index
                         << "+%" << CSeqNo::incseq(bufseq, int(m_pRcvBuffer->capacity()) - 1)
@@ -10092,7 +10099,7 @@ int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool&
             }
             else
             {
-                LOGC(qrlog.Warn, log << CONID() << "No room to store incoming packet seqno " << rpkt.m_iSeqNo
+                LOGC(qrlog.Warn, log << CONID() << "No room to store incoming packet seqno " << rpkt.seqno()
                         << ", insert offset " << bufidx << ". "
                         << m_pRcvBuffer->strFullnessState(m_iRcvLastAck, steady_clock::now())
                     );
@@ -10211,7 +10218,7 @@ int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool&
         // Empty buffer info in case of groupwise receiver.
         // There's no way to obtain this information here.
 
-        LOGC(qrlog.Debug, log << CONID() << "RECEIVED: %" << rpkt.m_iSeqNo
+        LOGC(qrlog.Debug, log << CONID() << "RECEIVED: %" << rpkt.seqno()
                 << bufinfo.str()
                 << " RSL=" << expectspec.str()
                 << " SN=" << s_rexmitstat_str[pktrexmitflag]
@@ -10225,12 +10232,12 @@ int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool&
         {
             HLOGC(qrlog.Debug,
                       log << CONID()
-                          << "CONTIGUITY CHECK: sequence distance: " << CSeqNo::seqoff(m_iRcvCurrSeqNo, rpkt.m_iSeqNo));
+                          << "CONTIGUITY CHECK: sequence distance: " << CSeqNo::seqoff(m_iRcvCurrSeqNo, rpkt.seqno()));
 
-            if (CSeqNo::seqcmp(rpkt.m_iSeqNo, CSeqNo::incseq(m_iRcvCurrSeqNo)) > 0) // Loss detection.
+            if (CSeqNo::seqcmp(rpkt.seqno(), CSeqNo::incseq(m_iRcvCurrSeqNo)) > 0) // Loss detection.
             {
                 int32_t seqlo = CSeqNo::incseq(m_iRcvCurrSeqNo);
-                int32_t seqhi = CSeqNo::decseq(rpkt.m_iSeqNo);
+                int32_t seqhi = CSeqNo::decseq(rpkt.seqno());
                 w_srt_loss_seqs.push_back(make_pair(seqlo, seqhi));
                 HLOGC(qrlog.Debug, log << "pkt/LOSS DETECTED: %" << seqlo << " - %" << seqhi);
             }
@@ -10238,9 +10245,9 @@ int srt::CUDT::handleSocketPacketReception(const vector<CUnit*>& incoming, bool&
 
         // Update the current largest sequence number that has been received.
         // Or it is a retransmitted packet, remove it from receiver loss list.
-        if (CSeqNo::seqcmp(rpkt.m_iSeqNo, m_iRcvCurrSeqNo) > 0)
+        if (CSeqNo::seqcmp(rpkt.seqno(), m_iRcvCurrSeqNo) > 0)
         {
-            m_iRcvCurrSeqNo = rpkt.m_iSeqNo; // Latest possible received
+            m_iRcvCurrSeqNo = rpkt.seqno(); // Latest possible received
         }
         else
         {
@@ -10288,7 +10295,7 @@ int srt::CUDT::processData(CUnit* in_unit)
         // Search the sequence in the loss record.
         rexmit_reason = " by ";
         ScopedLock lock(m_RcvLossLock);
-        if (!m_pRcvLossList->find(packet.m_iSeqNo, packet.m_iSeqNo))
+        if (!m_pRcvLossList->find(packet.seqno(), packet.seqno()))
             rexmit_reason += "BLIND";
         else
             rexmit_reason += "NAKREPORT";
@@ -10332,7 +10339,7 @@ int srt::CUDT::processData(CUnit* in_unit)
     // Conditions and any extra data required for the packet
     // this function will extract and test as needed.
 
-    const bool unordered = CSeqNo::seqcmp(packet.m_iSeqNo, m_iRcvCurrSeqNo) <= 0;
+    const bool unordered = CSeqNo::seqcmp(packet.seqno(), m_iRcvCurrSeqNo) <= 0;
 
     // Retransmitted and unordered packets do not provide expected measurement.
     // We expect the 16th and 17th packet to be sent regularly,
@@ -10358,7 +10365,7 @@ int srt::CUDT::processData(CUnit* in_unit)
     // supply the missing packet(s), and the loss will no longer be visible for the code that follows.
     if (packet.getMsgSeq(m_bPeerRexmitFlag) != SRT_MSGNO_CONTROL) // disregard filter-control packets, their seq may mean nothing
     {
-        const int diff = CSeqNo::seqoff(m_iRcvCurrPhySeqNo, packet.m_iSeqNo);
+        const int diff = CSeqNo::seqoff(m_iRcvCurrPhySeqNo, packet.seqno());
         // Difference between these two sequence numbers is expected to be:
         // 0 - duplicated last packet (theory only)
         // 1 - subsequent packet (alright)
@@ -10374,13 +10381,13 @@ int srt::CUDT::processData(CUnit* in_unit)
 
             HLOGC(qrlog.Debug,
                   log << CONID() << "LOSS STATS: n=" << loss << " SEQ: [" << CSeqNo::incseq(m_iRcvCurrPhySeqNo) << " "
-                      << CSeqNo::decseq(packet.m_iSeqNo) << "]");
+                      << CSeqNo::decseq(packet.seqno()) << "]");
         }
 
         if (diff > 0)
         {
             // Record if it was further than latest
-            m_iRcvCurrPhySeqNo = packet.m_iSeqNo;
+            m_iRcvCurrPhySeqNo = packet.seqno();
         }
     }
 
@@ -10446,7 +10453,7 @@ int srt::CUDT::processData(CUnit* in_unit)
         // offset from RcvLastAck in RcvBuffer must remain valid between seqoff() and addData()
         UniqueLock recvbuf_acklock(m_RcvBufferLock);
         // Needed for possibly check for needsQuickACK.
-        const bool incoming_belated = (CSeqNo::seqcmp(in_unit->m_Packet.m_iSeqNo, m_pRcvBuffer->getStartSeqNo()) < 0);
+        const bool incoming_belated = (CSeqNo::seqcmp(in_unit->m_Packet.seqno(), m_pRcvBuffer->getStartSeqNo()) < 0);
 
         const int res = handleSocketPacketReception(incoming,
                 (new_inserted),
@@ -10731,7 +10738,7 @@ void srt::CUDT::updateIdleLinkFrom(CUDT* source)
 void srt::CUDT::unlose(const CPacket &packet)
 {
     ScopedLock lg(m_RcvLossLock);
-    int32_t sequence = packet.m_iSeqNo;
+    int32_t sequence = packet.seqno();
     m_pRcvLossList->remove(sequence);
 
     // Rest of this code concerns only the "belated lossreport" feature.
@@ -10751,7 +10758,7 @@ void srt::CUDT::unlose(const CPacket &packet)
         {
             HLOGC(qrlog.Debug, log << "received out-of-band packet %" << sequence);
 
-            const int seqdiff = abs(CSeqNo::seqcmp(m_iRcvCurrSeqNo, packet.m_iSeqNo));
+            const int seqdiff = abs(CSeqNo::seqcmp(m_iRcvCurrSeqNo, packet.seqno()));
             enterCS(m_StatsLock);
             m_stats.traceReorderDistance = max(seqdiff, m_stats.traceReorderDistance);
             leaveCS(m_StatsLock);
@@ -10966,7 +10973,7 @@ int32_t srt::CUDT::bake(const sockaddr_any& addr, int32_t current_cookie, int co
 int srt::CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
 {
     // XXX ASSUMPTIONS:
-    // [[using assert(packet.m_iID == 0)]]
+    // [[using assert(packet.id() == 0)]]
 
     HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: received a connection request");
 
@@ -11054,7 +11061,7 @@ int srt::CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
         // array need not be aligned to int32_t - changed to union in a hope that using int32_t
         // inside a union will enforce whole union to be aligned to int32_t.
         hs.m_iCookie = cookie_val;
-        packet.m_iID = hs.m_iID;
+        packet.set_id(hs.m_iID);
 
         // Ok, now's the time. The listener sets here the version 5 handshake,
         // even though the request was 4. This is because the old client would
@@ -11122,7 +11129,7 @@ int srt::CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
         HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: ... correct (ORIGINAL) cookie. Proceeding.");
     }
 
-    int32_t id = hs.m_iID;
+    SRTSOCKET id = hs.m_iID;
 
     // HANDSHAKE: The old client sees the version that does not match HS_VERSION_UDT4 (5).
     // In this case it will respond with URQ_ERROR_REJECT. Rest of the data are the same
@@ -11170,8 +11177,8 @@ int srt::CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
         hs.m_iReqType = URQFailure(m_RejectReason);
         size_t size   = CHandShake::m_iContentSize;
         hs.store_to((packet.m_pcData), (size));
-        packet.m_iID        = id;
-        setPacketTS(packet, steady_clock::now());
+        packet.set_id(id);
+        setPacketTS((packet), steady_clock::now());
         HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: SENDING HS (e): " << hs.show());
         m_pSndQueue->sendto(addr, packet, use_source_addr);
     }
@@ -11282,7 +11289,7 @@ int srt::CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
                 CPacket rsp;
                 setPacketTS((rsp), steady_clock::now());
                 rsp.pack(UMSG_SHUTDOWN);
-                rsp.m_iID = m_PeerID;
+                rsp.set_id(m_PeerID);
                 m_pSndQueue->sendto(addr, rsp, use_source_addr);
             }
             else
@@ -11293,7 +11300,7 @@ int srt::CUDT::processConnectRequest(const sockaddr_any& addr, CPacket& packet)
                 size_t size = CHandShake::m_iContentSize;
                 hs.store_to((packet.m_pcData), (size));
                 packet.setLength(size);
-                packet.m_iID = id;
+                packet.set_id(id);
                 setPacketTS(packet, steady_clock::now());
                 HLOGC(cnlog.Debug, log << CONID() << "processConnectRequest: SENDING HS (a): " << hs.show());
                 m_pSndQueue->sendto(addr, packet, use_source_addr);
diff --git a/srtcore/core.h b/srtcore/core.h
index 9d5fa4c3a..20b361db9 100644
--- a/srtcore/core.h
+++ b/srtcore/core.h
@@ -409,7 +409,7 @@ class CUDT
 
     static void setPacketTS(CPacket& p, const time_point& start_time, const time_point& ts)
     {
-        p.m_iTimeStamp = makeTS(ts, start_time);
+        p.set_timestamp(makeTS(ts, start_time));
     }
 
     /// @brief Set the timestamp field of the packet using the provided value (no check)
diff --git a/srtcore/packet.cpp b/srtcore/packet.cpp
index fbb56a42c..b41ed6b9b 100644
--- a/srtcore/packet.cpp
+++ b/srtcore/packet.cpp
@@ -179,10 +179,6 @@ CPacket::CPacket()
     : m_nHeader() // Silences GCC 12 warning "used uninitialized".
     , m_extra_pad()
     , m_data_owned(false)
-    , m_iSeqNo((int32_t&)(m_nHeader[SRT_PH_SEQNO]))
-    , m_iMsgNo((int32_t&)(m_nHeader[SRT_PH_MSGNO]))
-    , m_iTimeStamp((int32_t&)(m_nHeader[SRT_PH_TIMESTAMP]))
-    , m_iID((int32_t&)(m_nHeader[SRT_PH_ID]))
     , m_pcData((char*&)(m_PacketVector[PV_DATA].dataRef()))
 {
     m_nHeader.clear();
@@ -601,7 +597,7 @@ inline void SprintSpecialWord(std::ostream& os, int32_t val)
 std::string CPacket::Info()
 {
     std::ostringstream os;
-    os << "TARGET=@" << m_iID << " ";
+    os << "TARGET=@" << id() << " ";
 
     if (isControl())
     {
diff --git a/srtcore/packet.h b/srtcore/packet.h
index 027d5f0b3..9b757118f 100644
--- a/srtcore/packet.h
+++ b/srtcore/packet.h
@@ -352,12 +352,15 @@ class CPacket
     CPacket(const CPacket&);
 
 public:
-    int32_t& m_iSeqNo;     // alias: sequence number
-    int32_t& m_iMsgNo;     // alias: message number
-    int32_t& m_iTimeStamp; // alias: timestamp
-    int32_t& m_iID;        // alias: destination SRT socket ID
     char*&   m_pcData;     // alias: payload (data packet) / control information fields (control packet)
 
+    SRTU_PROPERTY_RO(SRTSOCKET, id, SRTSOCKET(m_nHeader[SRT_PH_ID]));
+    SRTU_PROPERTY_WO_ARG(SRTSOCKET, id, m_nHeader[SRT_PH_ID] = int32_t(arg));
+
+    SRTU_PROPERTY_RW(int32_t, seqno, m_nHeader[SRT_PH_SEQNO]);
+    SRTU_PROPERTY_RW(int32_t, msgflags, m_nHeader[SRT_PH_MSGNO]);
+    SRTU_PROPERTY_RW(int32_t, timestamp, m_nHeader[SRT_PH_TIMESTAMP]);
+
     // Experimental: sometimes these references don't work!
     char* getData();
     char* release();
diff --git a/srtcore/packetfilter.cpp b/srtcore/packetfilter.cpp
index 37785f43a..a8da12537 100644
--- a/srtcore/packetfilter.cpp
+++ b/srtcore/packetfilter.cpp
@@ -226,7 +226,7 @@ bool srt::PacketFilter::packControlPacket(int32_t seq, int kflg, CPacket& w_pack
     // - Crypto
     // - Message Number
     // will be set to 0/false
-    w_packet.m_iMsgNo = SRT_MSGNO_CONTROL | MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO);
+    w_packet.set_msgflags(SRT_MSGNO_CONTROL | MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO));
 
     // ... and then fix only the Crypto flags
     w_packet.setMsgCryptoFlags(EncryptionKeySpec(kflg));
diff --git a/srtcore/queue.cpp b/srtcore/queue.cpp
index cf0016901..345151b4e 100644
--- a/srtcore/queue.cpp
+++ b/srtcore/queue.cpp
@@ -900,7 +900,7 @@ void srt::CRendezvousQueue::updateConnStatus(EReadStatus rst, EConnectStatus cst
 
     // Need a stub value for a case when there's no unit provided ("storage depleted" case).
     // It should be normally NOT IN USE because in case of "storage depleted", rst != RST_OK.
-    const SRTSOCKET dest_id = pkt ? pkt->m_iID : 0;
+    const SRTSOCKET dest_id = pkt ? pkt->id() : 0;
 
     // If no socket were qualified for further handling, finish here.
     // Otherwise toRemove and toProcess contain items to handle.
@@ -1385,7 +1385,7 @@ srt::EReadStatus srt::CRcvQueue::worker_RetrieveUnit(int32_t& w_id, CUnit*& w_un
 
     if (rst == RST_OK)
     {
-        w_id = w_unit->m_Packet.m_iID;
+        w_id = w_unit->m_Packet.id();
         HLOGC(qrlog.Debug,
               log << "INCOMING PACKET: FROM=" << w_addr.str() << " BOUND=" << m_pChannel->bindAddressAny().str() << " "
                   << w_unit->m_Packet.Info());
diff --git a/srtcore/utilities.h b/srtcore/utilities.h
index 258a2fdc8..4e9ed5b85 100644
--- a/srtcore/utilities.h
+++ b/srtcore/utilities.h
@@ -1280,6 +1280,7 @@ inline ValueType avg_iir_w(ValueType old_value, ValueType new_value, size_t new_
 #define SRTU_PROPERTY_RR(type, name, field) type name() { return field; }
 #define SRTU_PROPERTY_RO(type, name, field) type name() const { return field; }
 #define SRTU_PROPERTY_WO(type, name, field) void set_##name(type arg) { field = arg; }
+#define SRTU_PROPERTY_WO_ARG(type, name, expr) void set_##name(type arg) { expr; }
 #define SRTU_PROPERTY_WO_CHAIN(otype, type, name, field) otype& set_##name(type arg) { field = arg; return *this; }
 #define SRTU_PROPERTY_RW(type, name, field) SRTU_PROPERTY_RO(type, name, field); SRTU_PROPERTY_WO(type, name, field)
 #define SRTU_PROPERTY_RRW(type, name, field) SRTU_PROPERTY_RR(type, name, field); SRTU_PROPERTY_WO(type, name, field)
diff --git a/srtcore/window.h b/srtcore/window.h
index 132440368..dbe4b7179 100644
--- a/srtcore/window.h
+++ b/srtcore/window.h
@@ -244,7 +244,7 @@ class CPktTimeWindow: CPktTimeWindowTools
    void probeArrival(const CPacket& pkt, bool unordered)
    {
        SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
-       const int inorder16 = pkt.m_iSeqNo & PUMASK_SEQNO_PROBE;
+       const int inorder16 = pkt.seqno() & PUMASK_SEQNO_PROBE;
 
        // for probe1, we want 16th packet
        if (inorder16 == 0)
@@ -266,7 +266,7 @@ class CPktTimeWindow: CPktTimeWindowTools
    void probe1Arrival(const CPacket& pkt, bool unordered)
    {
        SRT_ASSERT(m_zHeaderSize != 0 && m_zPayloadSize != 0);
-       if (unordered && pkt.m_iSeqNo == m_Probe1Sequence)
+       if (unordered && pkt.seqno() == m_Probe1Sequence)
        {
            // Reset the starting probe into "undefined", when
            // a packet has come as retransmitted before the
@@ -276,7 +276,7 @@ class CPktTimeWindow: CPktTimeWindowTools
        }
 
        m_tsProbeTime = sync::steady_clock::now();
-       m_Probe1Sequence = pkt.m_iSeqNo; // Record the sequence where 16th packet probe was taken
+       m_Probe1Sequence = pkt.seqno(); // Record the sequence where 16th packet probe was taken
    }
 
    /// Record the arrival time of the second probing packet and the interval between packet pairs.
@@ -292,7 +292,7 @@ class CPktTimeWindow: CPktTimeWindowTools
        // expected packet pair, behave as if the 17th packet was lost.
 
        // no start point yet (or was reset) OR not very next packet
-       if (m_Probe1Sequence == SRT_SEQNO_NONE || CSeqNo::incseq(m_Probe1Sequence) != pkt.m_iSeqNo)
+       if (m_Probe1Sequence == SRT_SEQNO_NONE || CSeqNo::incseq(m_Probe1Sequence) != pkt.seqno())
            return;
 
        // Grab the current time before trying to acquire
diff --git a/test/test_buffer_rcv.cpp b/test/test_buffer_rcv.cpp
index 0c67fa91c..554c6aae5 100644
--- a/test/test_buffer_rcv.cpp
+++ b/test/test_buffer_rcv.cpp
@@ -54,22 +54,25 @@ class CRcvBufferReadMsg
         EXPECT_NE(unit, nullptr);
 
         CPacket& packet = unit->m_Packet;
-        packet.m_iSeqNo = seqno;
-        packet.m_iTimeStamp = ts;
+        packet.set_seqno(seqno);
+        packet.set_timestamp(ts);
 
         packet.setLength(m_payload_sz);
-        generatePayload(packet.data(), packet.getLength(), packet.m_iSeqNo);
+        generatePayload(packet.data(), packet.getLength(), packet.seqno());
 
-        packet.m_iMsgNo = msgno;
-        packet.m_iMsgNo |= PacketBoundaryBits(PB_SUBSEQUENT);
+        int32_t pktMsgFlags = msgno;
+        pktMsgFlags |= PacketBoundaryBits(PB_SUBSEQUENT);
         if (pb_first)
-            packet.m_iMsgNo |= PacketBoundaryBits(PB_FIRST);
+            pktMsgFlags |= PacketBoundaryBits(PB_FIRST);
         if (pb_last)
-            packet.m_iMsgNo |= PacketBoundaryBits(PB_LAST);
+            pktMsgFlags |= PacketBoundaryBits(PB_LAST);
+
+        if (!out_of_order)
+            pktMsgFlags |= MSGNO_PACKET_INORDER::wrap(1);
+        packet.set_msgflags(pktMsgFlags);
 
         if (!out_of_order)
         {
-            packet.m_iMsgNo |= MSGNO_PACKET_INORDER::wrap(1);
             EXPECT_TRUE(packet.getMsgOrderFlag());
         }
 
diff --git a/test/test_crypto.cpp b/test/test_crypto.cpp
index ce68dd32e..f4fa7f614 100644
--- a/test/test_crypto.cpp
+++ b/test/test_crypto.cpp
@@ -85,9 +85,9 @@ namespace srt
         const int inorder = 1;
         const int kflg = m_crypt.getSndCryptoFlags();
 
-        pkt.m_iSeqNo = seqno;
-        pkt.m_iMsgNo = msgno | inorder | PacketBoundaryBits(PB_SOLO) | MSGNO_ENCKEYSPEC::wrap(kflg);;
-        pkt.m_iTimeStamp = 356;
+        pkt.set_seqno(seqno);
+        pkt.set_msgflags(msgno | inorder | PacketBoundaryBits(PB_SOLO) | MSGNO_ENCKEYSPEC::wrap(kflg));
+        pkt.set_timestamp(356);
 
         std::iota(pkt.data(), pkt.data() + pld_size, '0');
         pkt.setLength(pld_size);
@@ -103,7 +103,6 @@ namespace srt
         // Modify the payload and expect auth to fail.
         pkt_enc->data()[10] = '5';
         EXPECT_EQ(m_crypt.decrypt(*pkt_enc.get()), ENCS_FAILED);
-        
     }
 
 } // namespace srt
diff --git a/test/test_fec_rebuilding.cpp b/test/test_fec_rebuilding.cpp
index 602ff6d13..581d406fd 100644
--- a/test/test_fec_rebuilding.cpp
+++ b/test/test_fec_rebuilding.cpp
@@ -809,7 +809,7 @@ TEST_F(TestFECRebuilding, NoRebuild)
     // - Crypto
     // - Message Number
     // will be set to 0/false
-    fecpkt->m_iMsgNo = MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO);
+    fecpkt->set_msgflags(MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO));
 
     // ... and then fix only the Crypto flags
     fecpkt->setMsgCryptoFlags(EncryptionKeySpec(0));
@@ -886,7 +886,7 @@ TEST_F(TestFECRebuilding, Rebuild)
     // - Crypto
     // - Message Number
     // will be set to 0/false
-    fecpkt->m_iMsgNo = MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO);
+    fecpkt->set_msgflags(MSGNO_PACKET_BOUNDARY::wrap(PB_SOLO));
 
     // ... and then fix only the Crypto flags
     fecpkt->setMsgCryptoFlags(EncryptionKeySpec(0));
@@ -904,7 +904,7 @@ TEST_F(TestFECRebuilding, Rebuild)
 
     // Set artificially the SN_REXMIT flag in the skipped source packet
     // because the rebuilt packet shall have REXMIT flag set.
-    skipped.m_iMsgNo |= MSGNO_REXMIT::wrap(true);
+    skipped.set_msgflags(skipped.msgflags() | MSGNO_REXMIT::wrap(true));
 
     // Compare the header
     EXPECT_EQ(skipped.getHeader()[SRT_PH_SEQNO], rebuilt.hdr[SRT_PH_SEQNO]);