inet::rtp::RtpPayloadSender Class Reference

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_t	_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_t	_timeStampBase = 0
	The first rtp time stamp used for created rtp data packets. More...
uint32_t	_timeStamp = 0
	The current rtp time stamp. More...
uint16_t	_sequenceNumberBase = 0
	The first sequence number used for created rtp data packets. More...
uint16_t	_sequenceNumber = 0
	The current sequence number. More...
SenderStatus	_status = static_cast<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

SenderStatus

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

RtpPayloadSender()

inet::rtp::RtpPayloadSender::RtpPayloadSender

(

)

Constructor.

{
}

~RtpPayloadSender()

inet::rtp::RtpPayloadSender::~RtpPayloadSender ( )

virtual

Destructor.

Calls closeSourceFile.

{
    closeSourceFile();
    cancelAndDelete(_reminderMessage);
}

Member Function Documentation

closeSourceFile()

void inet::rtp::RtpPayloadSender::closeSourceFile ( )

protectedvirtual

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

{
    _inputFileStream.close();
}

Referenced by ~RtpPayloadSender().

endOfFile()

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().

{
    _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");
}

Referenced by handleMessage(), and play().

handleMessage()

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 = check_and_cast<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!");
    }
}

initialize()

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.

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

initializeSenderModule()

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.

{
    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;
}

Referenced by handleMessage().

openSourceFile()

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.

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

Referenced by initializeSenderModule().

pause()

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.

{
    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");
}

Referenced by handleMessage().

play()

void inet::rtp::RtpPayloadSender::play ( )

protectedvirtual

Starts data transmission.

Every sender module must implement this method.

{
    _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();
    }
}

Referenced by handleMessage().

playUntilByte()

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.

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

Referenced by handleMessage().

playUntilTime()

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.

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

Referenced by handleMessage().

seekByte()

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.

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

Referenced by handleMessage().

seekTime()

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.

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

Referenced by handleMessage().

sendPacket()

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.

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

Referenced by handleMessage(), and play().

stop()

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.

{
    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");
}

Referenced by handleMessage().

Member Data Documentation

_clockRate

int inet::rtp::RtpPayloadSender::_clockRate = 0

protected

The clock rate in ticks per second this sender uses.

Referenced by initialize(), and initializeSenderModule().

_inputFileStream

std::ifstream inet::rtp::RtpPayloadSender::_inputFileStream

protected

The input file stream for the data file.

Referenced by closeSourceFile(), and openSourceFile().

_mtu

int inet::rtp::RtpPayloadSender::_mtu = 0

protected

The maximum size of an RtpPacket.

Referenced by initialize(), and initializeSenderModule().

_payloadType

int inet::rtp::RtpPayloadSender::_payloadType = -1

protected

The payload type this sender creates.

Referenced by initialize(), and initializeSenderModule().

_reminderMessage

cMessage* inet::rtp::RtpPayloadSender::_reminderMessage = nullptr

protected

A self message used as timer for the moment the next packet must be sent.

It's a member variable because when playing gets paused or stopped the timer must be cancelled.

Referenced by handleMessage(), initialize(), pause(), stop(), and ~RtpPayloadSender().

_sequenceNumber

uint16_t inet::rtp::RtpPayloadSender::_sequenceNumber = 0

protected

The current sequence number.

Referenced by initialize().

_sequenceNumberBase

uint16_t inet::rtp::RtpPayloadSender::_sequenceNumberBase = 0

protected

The first sequence number used for created rtp data packets.

The value is chosen randomly.

Referenced by initialize(), and initializeSenderModule().

_ssrc

uint32_t inet::rtp::RtpPayloadSender::_ssrc = 0

protected

The ssrc identifier of this sender module.

Referenced by endOfFile(), initialize(), initializeSenderModule(), pause(), play(), and stop().

_status

SenderStatus inet::rtp::RtpPayloadSender::_status = static_cast<SenderStatus>(-1)

protected

The current state of data transmission.

Referenced by endOfFile(), initializeSenderModule(), pause(), play(), and stop().

_timeStamp

uint32_t inet::rtp::RtpPayloadSender::_timeStamp = 0

protected

The current rtp time stamp.

Referenced by initialize(), and play().

_timeStampBase

uint32_t inet::rtp::RtpPayloadSender::_timeStampBase = 0

protected

The first rtp time stamp used for created rtp data packets.

The value is chosen randomly.

Referenced by initialize(), and initializeSenderModule().

---

The documentation for this class was generated from the following files:

• RtpPayloadSender.h
• RtpPayloadSender.cc