miprtpmessage.h

Go to the documentation of this file.

/*
    
  This file is a part of EMIPLIB, the EDM Media over IP Library.
  
  Copyright (C) 2006-2011  Hasselt University - Expertise Centre for
                      Digital Media (EDM) (http://www.edm.uhasselt.be)

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  
  USA

*/

#ifndef MIPRTPMESSAGE_H

#define MIPRTPMESSAGE_H

#include "mipconfig.h"
#include "mipmessage.h"
#include "miptime.h"
#include <jrtplib3/rtpsession.h>
#include <jrtplib3/rtppacket.h>
#include <string.h>

#define MIPRTPMESSAGE_TYPE_SEND                                                                         0x00000001
#define MIPRTPMESSAGE_TYPE_RECEIVE                                                                      0x00000002

class EMIPLIB_IMPORTEXPORT MIPRTPSendMessage : public MIPMessage
{
public:
        MIPRTPSendMessage(uint8_t *pData, size_t dataLength, uint8_t payloadType, bool marker,
                          uint32_t tsInc, bool deleteData = true) : MIPMessage(MIPMESSAGE_TYPE_RTP, MIPRTPMESSAGE_TYPE_SEND)
                                                                                                        { m_pData = pData; m_dataLength = dataLength; m_payloadType = payloadType; m_marker = marker; m_tsInc = tsInc; m_deleteData = deleteData; }
        ~MIPRTPSendMessage()                                                                            { if (m_deleteData) delete [] m_pData; }

        const uint8_t *getPayload() const                                                               { return m_pData; }

        size_t getPayloadLength() const                                                                 { return m_dataLength; }

        uint8_t getPayloadType() const                                                                  { return m_payloadType; }

        bool getMarker() const                                                                          { return m_marker; }

        uint32_t getTimestampIncrement() const                                                          { return m_tsInc; }

        void setSamplingInstant(MIPTime t)                                                              { m_samplingInstant = t; }

        MIPTime getSamplingInstant() const                                                              { return m_samplingInstant; }
private:
        uint8_t *m_pData;
        size_t m_dataLength;
        uint8_t m_payloadType;
        bool m_marker;
        uint32_t m_tsInc;
        bool m_deleteData;
        MIPTime m_samplingInstant;
};

#define MIPRTPMESSAGE_MAXCNAMELENGTH                                                                    256     

class EMIPLIB_IMPORTEXPORT MIPRTPReceiveMessage : public MIPMessage
{
public:
        MIPRTPReceiveMessage(jrtplib::RTPPacket *pPack, const uint8_t *pCName, size_t cnameLength, bool deletePacket = true, jrtplib::RTPSession *pSess = 0) : MIPMessage(MIPMESSAGE_TYPE_RTP, MIPRTPMESSAGE_TYPE_RECEIVE), m_jitter(0)
                                                                                                        { m_deletePacket = deletePacket; m_pPack = pPack; if (cnameLength > MIPRTPMESSAGE_MAXCNAMELENGTH) m_cnameLength = MIPRTPMESSAGE_MAXCNAMELENGTH; else m_cnameLength = cnameLength; if (cnameLength > 0) memcpy(m_cname,pCName,m_cnameLength); m_tsUnit = -1; m_tsUnitEstimate = -1; m_timingInfoSet = false; m_sourceID = 0; m_pSession = pSess; }
        ~MIPRTPReceiveMessage()                                                                         { if (m_deletePacket) { if (m_pSession) m_pSession->DeletePacket(m_pPack); else delete m_pPack; } }

        const jrtplib::RTPPacket *getPacket() const                                                     { return m_pPack; }

        const uint8_t *getCName() const                                                                 { return m_cname; }

        size_t getCNameLength() const                                                                   { return m_cnameLength; }

        MIPTime getJitter() const                                                                       { return m_jitter; }

        void setJitter(MIPTime t)                                                                       { m_jitter = t; }

        real_t getTimestampUnit() const                                                                 { return m_tsUnit; }

        void setTimestampUnit(real_t unit)                                                              { m_tsUnit = unit; }

        real_t getTimestampUnitEstimate() const                                                         { return m_tsUnitEstimate; }

        void setTimestampUnitEstimate(real_t unit)                                                      { m_tsUnitEstimate = unit; }

        bool isTimingInfoSet() const                                                                    { return m_timingInfoSet; }

        void setTimingInfo(MIPTime t, uint32_t timestamp)                                               { m_timingInfWallclock = t; m_timingInfTimestamp = timestamp; m_timingInfoSet = true; }
        
        bool getTimingInfo(MIPTime *t, uint32_t *timestamp) const                                       { if (!m_timingInfoSet) return false; *t = m_timingInfWallclock; *timestamp = m_timingInfTimestamp; return true; }

        void setSourceID(uint64_t sourceID)                                                             { m_sourceID = sourceID; }
        
        uint64_t getSourceID() const                                                                    { return m_sourceID; }
private:
        jrtplib::RTPPacket *m_pPack;
        jrtplib::RTPSession *m_pSession;
        uint8_t m_cname[MIPRTPMESSAGE_MAXCNAMELENGTH];
        size_t m_cnameLength;
        bool m_deletePacket;
        MIPTime m_jitter;
        real_t m_tsUnit, m_tsUnitEstimate;
        bool m_timingInfoSet;
        MIPTime m_timingInfWallclock;
        uint32_t m_timingInfTimestamp;
        uint64_t m_sourceID;
};

#endif // MIPRTPMESSAGE_H