The class RTPPayloadSender is the base class for all modules creating RTP data packets. More...

#include <RTPPayloadSender.h>

Inheritance diagram for inet::rtp::RTPPayloadSender:

Public Member Functions
	RTPPayloadSender ()
	Constructor. More...

virtual	~RTPPayloadSender ()
	Destructor. More...

Protected Types
enum	SenderStatus { STOPPED, PLAYING }
	A sender module's transmission can be in different states. More...

Protected Member Functions
virtual void	initialize () override
	Chooses sequence number and time stamp base values and reads the omnet parameter "mtu". More...

virtual void	handleMessage (cMessage *msg) override

virtual void	initializeSenderModule (RTPInnerPacket *)
	This method is called when a newly create sender module received its initialization message from profile module. More...

virtual void	openSourceFile (const char *fileName)
	This method is called by initializeSenderModule and opens the source data file as an inputFileStream stored in member variable _inputFileStream. More...

virtual void	closeSourceFile ()
	This method is called by the destructor and closes the data file. More...

virtual void	play ()
	Starts data transmission. More...

virtual void	playUntilTime (simtime_t moment)
	Starts transmission from the current file position and plays until given time (relative to start of file) is reached. More...

virtual void	playUntilByte (int position)
	Starts transmission from the current file position and plays until given byte position (excluding file header) is reached. More...

virtual void	pause ()
	When data is being transmitted this methods suspends till a new PLAY command. More...

virtual void	seekTime (simtime_t moment)
	When the data transmission is paused the current position is changed to this time (relative to start of file). More...

virtual void	seekByte (int position)
	When the data transmission is paused the current position is changed to this byte position (excluding file header). More...

virtual void	stop ()
	This method stop data transmission and resets the sender module so that a following PLAY command would start the transmission at the beginning again. More...

virtual void	endOfFile ()
	This method gets called when the sender module reaches the end of file. More...

virtual bool	sendPacket ()
	This method gets called when one (or more) rtp data packets have to be sent. More...

Protected Attributes
std::ifstream	_inputFileStream
	The input file stream for the data file. More...

int	_mtu = 0
	The maximum size of an RTPPacket. More...

uint32	_ssrc = 0
	The ssrc identifier of this sender module. More...

int	_payloadType = -1
	The payload type this sender creates. More...

int	_clockRate = 0
	The clock rate in ticks per second this sender uses. More...

uint32	_timeStampBase = 0
	The first rtp time stamp used for created rtp data packets. More...

uint32	_timeStamp = 0
	The current rtp time stamp. More...

uint16	_sequenceNumberBase = 0
	The first sequence number used for created rtp data packets. More...

uint16	_sequenceNumber = 0
	The current sequence number. More...

SenderStatus	_status = (SenderStatus)-1
	The current state of data transmission. More...

cMessage *	_reminderMessage = nullptr
	A self message used as timer for the moment the next packet must be sent. More...

Detailed Description

The class RTPPayloadSender is the base class for all modules creating RTP data packets.

It provides functionality needed by every RTP data packet sender like opening and closing the data file and choosing sequence number and time stamp start values.

Member Enumeration Documentation

enum inet::rtp::RTPPayloadSender::SenderStatus

protected

A sender module's transmission can be in different states.

Enumerator
STOPPED
PLAYING	Data is being sent.

                       {
         STOPPED,    //< No transmission.
         PLAYING    
     };

Constructor & Destructor Documentation

inet::rtp::RTPPayloadSender::RTPPayloadSender ( )

Constructor.

30 {

31 }

inet::rtp::RTPPayloadSender::~RTPPayloadSender ( )

virtual

Destructor.

Calls closeSourceFile.

 {
     closeSourceFile();
     cancelAndDelete(_reminderMessage);
 }

Member Function Documentation

void inet::rtp::RTPPayloadSender::closeSourceFile ( )

protectedvirtual

This method is called by the destructor and closes the data file.

Referenced by ~RTPPayloadSender().

 {
     _inputFileStream.close();
 }

void inet::rtp::RTPPayloadSender::endOfFile ( )

protectedvirtual

This method gets called when the sender module reaches the end of file.

For the transmission it has the same effect like stop().

Referenced by handleMessage(), and play().

 {
     _status = STOPPED;
     RTPSenderStatusMessage *rssm = new RTPSenderStatusMessage("FINISHED");
     rssm->setStatus(RTP_SENDER_STATUS_FINISHED);
     RTPInnerPacket *rinpOut = new RTPInnerPacket("senderModuleStatus(FINISHED)");
     rinpOut->setSenderModuleStatusPkt(_ssrc, rssm);
     send(rinpOut, "profileOut");
 }

void inet::rtp::RTPPayloadSender::handleMessage ( cMessage * msg )

overrideprotectedvirtual

 {
     if (msg == _reminderMessage) {
         delete msg;
         _reminderMessage = nullptr;
         if (!sendPacket()) {
             endOfFile();
         }
     }
     else if (msg->getArrivalGateId() == findGate("profileIn")) {
         RTPInnerPacket *rinpIn = check_and_cast<RTPInnerPacket *>(msg);
         if (rinpIn->getType() == RTP_INP_INITIALIZE_SENDER_MODULE) {
             initializeSenderModule(rinpIn);
         }
         else if (rinpIn->getType() == RTP_INP_SENDER_MODULE_CONTROL) {
             RTPSenderControlMessage *rscm = (RTPSenderControlMessage *)(rinpIn->decapsulate());
             delete rinpIn;
             switch (rscm->getCommand()) {
                 case RTP_CONTROL_PLAY:
                     play();
                     break;
 
                 case RTP_CONTROL_PLAY_UNTIL_TIME:
                     playUntilTime(rscm->getCommandParameter1());
                     break;
 
                 case RTP_CONTROL_PLAY_UNTIL_BYTE:
                     playUntilByte(rscm->getCommandParameter1());
                     break;
 
                 case RTP_CONTROL_PAUSE:
                     pause();
                     break;
 
                 case RTP_CONTROL_STOP:
                     stop();
                     break;
 
                 case RTP_CONTROL_SEEK_TIME:
                     seekTime(rscm->getCommandParameter1());
                     break;
 
                 case RTP_CONTROL_SEEK_BYTE:
                     seekByte(rscm->getCommandParameter1());
                     break;
 
                 default:
                     throw cRuntimeError("unknown sender control message");
                     break;
             }
             delete rscm;
         }
     }
     else {
         throw cRuntimeError("Unknown message!");
     }
 }

void inet::rtp::RTPPayloadSender::initialize ( )

overrideprotectedvirtual

Chooses sequence number and time stamp base values and reads the omnet parameter "mtu".

Reimplemented in inet::rtp::RTPAVProfilePayload32Sender.

Referenced by inet::rtp::RTPAVProfilePayload32Sender::initialize().

 {
     cSimpleModule::initialize();
     _mtu = 0;
     _ssrc = 0;
     _payloadType = 0;
     _clockRate = 0;
     _timeStampBase = intrand(65535);
     _timeStamp = _timeStampBase;
     _sequenceNumberBase = intrand(0x7fffffff);
     _sequenceNumber = _sequenceNumberBase;
     _reminderMessage = nullptr;
 }

void inet::rtp::RTPPayloadSender::initializeSenderModule ( RTPInnerPacket * rinpIn )

protectedvirtual

This method is called when a newly create sender module received its initialization message from profile module.

It returns an RTP_INP_SENDER_MODULE_INITIALIZED message which

Reimplemented in inet::rtp::RTPAVProfilePayload32Sender.

Referenced by handleMessage(), and inet::rtp::RTPAVProfilePayload32Sender::initializeSenderModule().

 {
     EV_TRACE << "initializeSenderModule Enter" << endl;
     _mtu = rinpIn->getMTU();
     _ssrc = rinpIn->getSsrc();
     const char *fileName = rinpIn->getFileName();
     openSourceFile(fileName);
     delete rinpIn;
     RTPInnerPacket *rinpOut = new RTPInnerPacket("senderModuleInitialized()");
     rinpOut->setSenderModuleInitializedPkt(_ssrc, _payloadType, _clockRate, _timeStampBase, _sequenceNumberBase);
     send(rinpOut, "profileOut");
     _status = STOPPED;
     EV_TRACE << "initializeSenderModule Exit" << endl;
 }

void inet::rtp::RTPPayloadSender::openSourceFile ( const char * fileName )

protectedvirtual

This method is called by initializeSenderModule and opens the source data file as an inputFileStream stored in member variable _inputFileStream.

Most data formats can use this method directly, but when using a library for a certain data format which offers an own open routine this method must be overwritten.

Referenced by initializeSenderModule().

 {
     _inputFileStream.open(fileName);
     if (!_inputFileStream)
         throw cRuntimeError("Error opening data file '%s'", fileName);
 }

void inet::rtp::RTPPayloadSender::pause ( )

protectedvirtual

When data is being transmitted this methods suspends till a new PLAY command.

Implementation in sender modules is optional.

Referenced by handleMessage().

 {
     cancelAndDelete(_reminderMessage);
     _reminderMessage = nullptr;
     _status = STOPPED;
     RTPInnerPacket *rinpOut = new RTPInnerPacket("senderModuleStatus(PAUSED)");
     RTPSenderStatusMessage *rsim = new RTPSenderStatusMessage();
     rsim->setStatus(RTP_SENDER_STATUS_PAUSED);
     rinpOut->setSenderModuleStatusPkt(_ssrc, rsim);
     send(rinpOut, "profileOut");
 }

void inet::rtp::RTPPayloadSender::play ( )

protectedvirtual

Starts data transmission.

Every sender module must implement this method.

Referenced by handleMessage().

 {
     _status = PLAYING;
     RTPSenderStatusMessage *rssm = new RTPSenderStatusMessage("PLAYING");
     rssm->setStatus(RTP_SENDER_STATUS_PLAYING);
     rssm->setTimeStamp(_timeStamp);
     RTPInnerPacket *rinpOut = new RTPInnerPacket("senderModuleStatus(PLAYING)");
     rinpOut->setSenderModuleStatusPkt(_ssrc, rssm);
     send(rinpOut, "profileOut");
 
     if (!sendPacket()) {
         endOfFile();
     }
 }

void inet::rtp::RTPPayloadSender::playUntilByte ( int position )

protectedvirtual

Starts transmission from the current file position and plays until given byte position (excluding file header) is reached.

Implementation in sender modules is optional.

Referenced by handleMessage().

 {
     throw cRuntimeError("playUntilByte() not implemented");
 }

void inet::rtp::RTPPayloadSender::playUntilTime ( simtime_t moment )

protectedvirtual

Starts transmission from the current file position and plays until given time (relative to start of file) is reached.

Implementation in sender modules is optional.

Referenced by handleMessage().

 {
     throw cRuntimeError("playUntilTime() not implemented");
 }

void inet::rtp::RTPPayloadSender::seekByte ( int position )

protectedvirtual

When the data transmission is paused the current position is changed to this byte position (excluding file header).

Implementation in sender modules is optional.

Referenced by handleMessage().

 {
     throw cRuntimeError("seekByte() not implemented");
 }

void inet::rtp::RTPPayloadSender::seekTime ( simtime_t moment )

protectedvirtual

When the data transmission is paused the current position is changed to this time (relative to start of file).

Implementation in sender modules is optional.

Referenced by handleMessage().

 {
     throw cRuntimeError("seekTime() not implemented");
 }

bool inet::rtp::RTPPayloadSender::sendPacket ( )

protectedvirtual

This method gets called when one (or more) rtp data packets have to be sent.

Subclasses must overwrite this method to do something useful. This implementation doesn't send packets it just returns

Reimplemented in inet::rtp::RTPAVProfilePayload32Sender.

Referenced by handleMessage(), and play().

 {
     throw cRuntimeError("sendPacket() not implemented");
     return false;
 }

void inet::rtp::RTPPayloadSender::stop ( )

protectedvirtual

This method stop data transmission and resets the sender module so that a following PLAY command would start the transmission at the beginning again.

Referenced by handleMessage().

 {
     cancelAndDelete(_reminderMessage);
     _reminderMessage = nullptr;
     _status = STOPPED;
     RTPSenderStatusMessage *rssm = new RTPSenderStatusMessage("STOPPED");
     rssm->setStatus(RTP_SENDER_STATUS_STOPPED);
     RTPInnerPacket *rinp = new RTPInnerPacket("senderModuleStatus(STOPPED)");
     rinp->setSenderModuleStatusPkt(_ssrc, rssm);
     send(rinp, "profileOut");
 }