0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2024-12-13 22:11:15 +00:00
doom3-bfg/neo/sys/PacketProcessor.h
2012-12-14 13:10:52 +01:00

341 lines
11 KiB
C++

/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#ifndef __PACKET_PROCESSOR_H__
#define __PACKET_PROCESSOR_H__
/*
================================================
idPacketProcessor
================================================
*/
class idPacketProcessor
{
public:
// DG: workaround for GCC bug (can't link when compiling with -O0): put definitions in PacketProcessor.cpp
static const int RETURN_TYPE_NONE; // = 0;
static const int RETURN_TYPE_OOB; // = 1;
static const int RETURN_TYPE_INBAND; // = 2;
// DG end
typedef uint16 sessionId_t;
static const int NUM_LOBBY_TYPE_BITS = 2;
static const int LOBBY_TYPE_MASK = ( 1 << NUM_LOBBY_TYPE_BITS ) - 1;
static const sessionId_t SESSION_ID_INVALID = 0;
static const sessionId_t SESSION_ID_CONNECTIONLESS_PARTY = 1;
static const sessionId_t SESSION_ID_CONNECTIONLESS_GAME = 2;
static const sessionId_t SESSION_ID_CONNECTIONLESS_GAME_STATE = 3;
static const int BANDWIDTH_AVERAGE_PERIOD = 250;
idPacketProcessor()
{
Reset();
}
void Reset()
{
msgWritePos = 0;
fragmentSequence = 0;
droppedFrags = 0;
fragmentedSend = false;
reliable = idDataQueue< MAX_RELIABLE_QUEUE, MAX_MSG_SIZE >();
reliableSequenceSend = 1;
reliableSequenceRecv = 0;
numReliable = 0;
queuedReliableAck = -1;
unsentMsg = idBitMsg();
lastSendTime = 0;
outgoingRateTime = 0;
outgoingRateBytes = 0.0f;
incomingRateTime = 0;
incomingRateBytes = 0.0f;
outgoingBytes = 0;
incomingBytes = 0;
currentOutgoingRate = 0;
lastOutgoingRateTime = 0;
lastOutgoingBytes = 0;
currentIncomingRate = 0;
lastIncomingRateTime = 0;
lastIncomingBytes = 0;
fragmentAccumulator = 0;
}
static const int MAX_MSG_SIZE = 8000; // This is the max size you can pass into ProcessOutgoing
static const int MAX_FINAL_PACKET_SIZE = 1200; // Lowest/safe MTU across all our platforms to avoid fragmentation at the transport layer (which is poorly supported by consumer hardware and may cause nasty latency side effects)
static const int MAX_RELIABLE_QUEUE = 64;
// TypeInfo doesn't like sizeof( sessionId_t )?? and then fails to understand the #ifdef/#else/#endif
//static const int MAX_PACKET_SIZE = MAX_FINAL_PACKET_SIZE - 6 - sizeof( sessionId_t ); // Largest possible packet before headers and such applied (subtract some for various internal header data, and session id)
static const int MAX_PACKET_SIZE = MAX_FINAL_PACKET_SIZE - 6 - 2; // Largest possible packet before headers and such applied (subtract some for various internal header data, and session id)
static const int MAX_OOB_MSG_SIZE = MAX_PACKET_SIZE - 1; // We don't allow fragmentation for out-of-band msg's, and we need a byte for the header
private:
void QueueReliableAck( int lastReliable );
int FinalizeRead( idBitMsg& inMsg, idBitMsg& outMsg, int& userValue );
public:
bool CanSendMoreData() const;
void UpdateOutgoingRate( const int time, const int size );
void UpdateIncomingRate( const int time, const int size );
void RefreshRates( int time )
{
UpdateOutgoingRate( time, 0 );
UpdateIncomingRate( time, 0 );
}
// Used to queue reliable msg's, to be sent on the next ProcessOutgoing
bool QueueReliableMessage( byte type, const byte* data, int dataLen );
// Used to process a msg ready to be sent, could get fragmented into multiple fragments
bool ProcessOutgoing( const int time, const idBitMsg& msg, bool isOOB, int userData );
// Used to get each fragment for sending through the actual net connection
bool GetSendFragment( const int time, sessionId_t sessionID, idBitMsg& outMsg );
// Used to process a fragment received. Returns true when msg was reconstructed.
int ProcessIncoming( int time, sessionId_t expectedSessionID, idBitMsg& msg, idBitMsg& out, int& userData, const int peerNum );
// Returns true if there are more fragments to send
bool HasMoreFragments() const
{
return ( unsentMsg.GetRemainingData() > 0 );
}
// Num reliables not ack'd
int NumQueuedReliables()
{
return reliable.Num();
}
// True if we need to send a reliable ack
int NeedToSendReliableAck()
{
return queuedReliableAck >= 0 ? true : false;
}
// Used for out-of-band non connected peers
// This doesn't actually support fragmentation, it is just simply here to hide the
// header structure, so the caller doesn't have to skip over the header data.
static bool ProcessConnectionlessOutgoing( idBitMsg& msg, idBitMsg& out, int lobbyType, int userData );
static bool ProcessConnectionlessIncoming( idBitMsg& msg, idBitMsg& out, int& userData );
// Used to "peek" at a session id of a message fragment
static sessionId_t GetSessionID( idBitMsg& msg );
int GetNumReliables() const
{
return numReliable;
}
const byte* GetReliable( int i ) const
{
return reliableMsgPtrs[ i ];
}
int GetReliableSize( int i ) const
{
return reliableMsgSize[ i ];
}
void SetLastSendTime( int i )
{
lastSendTime = i;
}
int GetLastSendTime() const
{
return lastSendTime;
}
float GetOutgoingRateBytes() const
{
return outgoingRateBytes;
}
int GetOutgoingBytes() const
{
return outgoingBytes;
}
float GetIncomingRateBytes() const
{
return incomingRateBytes;
}
int GetIncomingBytes() const
{
return incomingBytes;
}
// more reliable computation, based on a suitably small interval
int GetOutgoingRate2() const
{
return currentOutgoingRate;
}
int GetIncomingRate2() const
{
return currentIncomingRate;
}
// decrease a fragmentation counter, so we reflect how much we're maxing the MTU
bool TickFragmentAccumulator()
{
if( fragmentAccumulator > 0 )
{
fragmentAccumulator--;
return true;
}
return false;
}
int GetReliableDataSize() const
{
return reliable.GetDataLength();
}
void VerifyEmptyReliableQueue( byte keepMsgBelowThis, byte replaceWithThisMsg );
private:
// Packet header types
static const int PACKET_TYPE_INBAND = 0; // In-band. Number of reliable msg's stored in userData portion of header
static const int PACKET_TYPE_OOB = 1; // Out-of-band. userData free to use by the caller. Cannot fragment.
static const int PACKET_TYPE_RELIABLE_ACK = 2; // Header type used to piggy-back on top of msgs to ack reliable msg's
static const int PACKET_TYPE_FRAGMENTED = 3; // The msg is fragmented, fragment type stored in the userData portion of header
// PACKET_TYPE_FRAGMENTED userData values
// DG: workaround for GCC bug (can't link when compiling with -O0): put definitions in PacketProcessor.cpp
static const int FRAGMENT_START; // = 0;
static const int FRAGMENT_MIDDLE; // = 1;
static const int FRAGMENT_END; // = 2;
// DG end
class idOuterPacketHeader
{
public:
idOuterPacketHeader() : sessionID( SESSION_ID_INVALID ) {}
idOuterPacketHeader( sessionId_t sessionID_ ) : sessionID( sessionID_ ) {}
void WriteToMsg( idBitMsg& msg )
{
msg.WriteUShort( sessionID );
}
void ReadFromMsg( idBitMsg& msg )
{
sessionID = msg.ReadUShort();
}
sessionId_t GetSessionID()
{
return sessionID;
}
private:
sessionId_t sessionID;
};
class idInnerPacketHeader
{
public:
idInnerPacketHeader() : type( 0 ), userData( 0 ) {}
idInnerPacketHeader( int inType, int inData ) : type( inType ), userData( inData ) {}
void WriteToMsg( idBitMsg& msg )
{
msg.WriteBits( type, 2 );
msg.WriteBits( userData, 6 );
}
void ReadFromMsg( idBitMsg& msg )
{
type = msg.ReadBits( 2 );
userData = msg.ReadBits( 6 );
}
int Type()
{
return type;
}
int Value()
{
return userData;
}
private:
int type;
int userData;
};
byte msgBuffer[ MAX_MSG_SIZE ]; // Buffer used to reconstruct the msg
int msgWritePos; // Write position into the msg reconstruction buffer
int fragmentSequence; // Fragment sequence number
int droppedFrags; // Number of dropped fragments
bool fragmentedSend; // Used to determine if the current send requires fragmenting
idDataQueue< MAX_RELIABLE_QUEUE, MAX_MSG_SIZE > reliable; // list of unacknowledged reliable messages
int reliableSequenceSend; // sequence number of the next reliable packet we're going to send to this peer
int reliableSequenceRecv; // sequence number of the last reliable packet we received from this peer
// These are for receiving reliables, you need to get these before the next process call or they will get cleared
int numReliable;
byte reliableBuffer[ MAX_MSG_SIZE ]; // We shouldn't have to hold more than this
const byte* reliableMsgPtrs[ MAX_RELIABLE_QUEUE ];
int reliableMsgSize[ MAX_RELIABLE_QUEUE ];
int queuedReliableAck; // Used to piggy back on the next send to ack reliables
idBitMsg unsentMsg;
byte unsentBuffer[ MAX_MSG_SIZE ]; // Buffer used hold the current msg until it's all sent
int lastSendTime;
// variables to keep track of the rate
int outgoingRateTime;
float outgoingRateBytes; // B/S
int incomingRateTime;
float incomingRateBytes; // B/S
int outgoingBytes;
int incomingBytes;
int currentOutgoingRate;
int lastOutgoingRateTime;
int lastOutgoingBytes;
int currentIncomingRate;
int lastIncomingRateTime;
int lastIncomingBytes;
int fragmentAccumulator; // counts max size packets we are sending for the net debug hud
};
#endif /* !__PACKET_PROCESSOR_H__ */