MprRtpDispatcher.h

Go to the documentation of this file.

//  
// Copyright (C) 2007-2016 SIPez LLC.  All rights reserved.
//
// Copyright (C) 2007-2008 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// $$

// Author: Alexander Chemeris <Alexander DOT Chemeris AT SIPez DOT com>

#ifndef _MprRtpDispatcher_h_
#define _MprRtpDispatcher_h_

// SYSTEM INCLUDES
// APPLICATION INCLUDES
#include <mp/MpResource.h>
//#include "mp/MpEvents.h"
#include <mp/MpRtpBuf.h>
#include <mp/MprnRtpStreamActivityMsg.h>
#include <utl/UtlString.h>
#include <utl/UtlInt.h>
#include <os/OsMsgQ.h>
#include <os/OsDateTime.h>
#include <os/OsLock.h>

// DEFINES
// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS
class OsMsgDispatcher;

class MprRtpDispatcher
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

   enum RtpStreamAffinity
   {
      ADDRESS_AND_PORT,
      MOST_RECENT_SSRC
   };

/* ============================ CREATORS ================================== */


   MprRtpDispatcher(const UtlString& rName, int connectionId);
   virtual ~MprRtpDispatcher();


/* ============================ MANIPULATORS ============================== */


   virtual OsStatus pushPacket(MpRtpBufPtr &pRtp) = 0;

   virtual void checkRtpStreamsActivity() = 0;

   virtual UtlBoolean connectOutput(int outputIdx, MpResource* pushRtpToResource) = 0;

   virtual UtlBoolean disconnectOutput(int outputIdx) = 0;

   inline void setNotificationDispatcher(OsMsgDispatcher *pMsgQ);
   inline void setNotificationsEnabled(UtlBoolean enabled);

   inline void setConnectionId(MpConnectionID connectionId);

   inline void setRtpInactivityTimeout(const OsTime &inactiveTime);
   static inline
   void setDefaultRtpInactivityTimeout(const OsTime &inactiveTime);

/* ============================ ACCESSORS ================================= */



/* ============================ INQUIRY =================================== */


     // Returns true, if notifications are enabled to be sent.
   inline UtlBoolean areNotificationsEnabled() const;


/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:

// The below define is to work around brokenness in VC6.  Details follow.
// In MSVC6, MprRtpDispatcherActiveSsrcs::lookupRtpStream fails to compile
// properly with MpRtpStream defined here as protected, as VC6 erroneously
// specifies that it 'cannot access protected struct decalred in class 'MprRtpDispatcher'
// despite the fact that MprRtpDispatcherActiveSrcs derives from 
// this class, and defines lookupRtpStream as protected.
// So, to work around this, if we're compiling with VC6, then make the
// struct public (which exposes it more than we want)...
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
public:
#endif

   struct MpRtpStream : public UtlInt
   {
      MpRtpStream()
      : mStreamId(-1)
      , mStreamActive(FALSE)
      , mAddress(0)
      , mPort(-1)
      , mpOutputResource(NULL)
      {}

      int                 mStreamId;       
      OsTime              mLastPacketTime; 
      UtlBoolean          mStreamActive;   
      int                 mAddress;        
      int                 mPort;           
      MpResource         *mpOutputResource;

      inline void pushPacket(MpRtpBufPtr &pRtp);

      inline void activate(int fromIp, int fromPort);

      inline void deactivate();

      UtlBoolean timeoutDeactivate(const OsTime &timeout);
      inline UtlBoolean isActive() const;

      inline RtpSRC getSSRC() const;

      inline void setSSRC(RtpSRC ssrc);
      OsStatus postStreamNotif(OsMsgDispatcher *pMsgQ,
                               const UtlString &resourceName,
                               MpConnectionID connId,
                               MprnRtpStreamActivityMsg::StreamState state) const;
   };
// The below define is to work around brokenness in VC6.  Details above the 
// struct definition.
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
protected:
#endif

   OsMutex          mMutex;          
   UtlString        mResourceName;   
   MpConnectionID   mConnectionId;   
   OsMsgDispatcher* mpEventMsgQ;     
   UtlBoolean       mNotificationsEnabled; 

   OsTime           mRtpInactiveTime; 

   static OsTime    smDefaultRtpInactiveTime; 

/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

   MprRtpDispatcher(const MprRtpDispatcher& rMprRtpDispatcher);

   MprRtpDispatcher& operator=(const MprRtpDispatcher& rhs);

};

/* ============================ INLINE METHODS ============================ */

void MprRtpDispatcher::setNotificationDispatcher(OsMsgDispatcher *pMsgQ)
{
   OsLock lock(mMutex);
   mpEventMsgQ = pMsgQ;
}

void MprRtpDispatcher::setNotificationsEnabled(UtlBoolean enabled)
{
   mNotificationsEnabled = enabled;
}

void MprRtpDispatcher::setConnectionId(MpConnectionID connectionId)
{
   OsLock lock(mMutex);
   mConnectionId = connectionId;
}

void MprRtpDispatcher::setRtpInactivityTimeout(const OsTime &inactiveTime)
{
   OsLock lock(mMutex);
   mRtpInactiveTime = inactiveTime;
}

void MprRtpDispatcher::setDefaultRtpInactivityTimeout(const OsTime &inactiveTime)
{
   smDefaultRtpInactiveTime = inactiveTime;
}

UtlBoolean MprRtpDispatcher::areNotificationsEnabled() const
{
   return mNotificationsEnabled;
}

void MprRtpDispatcher::MpRtpStream::pushPacket(MpRtpBufPtr &pRtp)
{
   OsDateTime::getCurTime(mLastPacketTime);
   mpOutputResource->pushBuffer(0, // input port on resource
                                pRtp);
}

void MprRtpDispatcher::MpRtpStream::activate(int fromIp, int fromPort)
{
   // Make sure that the output resource has been enabled
   // otherwise no audio
   if (mpOutputResource && !mpOutputResource->isEnabled())
   {
      // Reset decoder in preparation to handle new stream
      mpOutputResource->reset();
      mpOutputResource->enable();
   }

   // Mark stream as active and save sender IP.
   mStreamActive = TRUE;
   mAddress = fromIp;
   mPort = fromPort;

//   printf("Stream %X activated\n", getSSRC());
}

void MprRtpDispatcher::MpRtpStream::deactivate()
{
   // Mark stream as inactive
   mStreamActive = FALSE;

//   printf("Stream %X deactivated\n", getSSRC());
}

UtlBoolean MprRtpDispatcher::MpRtpStream::isActive() const
{
   return mStreamActive;
}

RtpSRC MprRtpDispatcher::MpRtpStream::getSSRC() const
{
   return getValue();
}

void MprRtpDispatcher::MpRtpStream::setSSRC(RtpSRC ssrc)
{
   // Reset decoder if this is not the first time setSSRC() is called.
   // Note, that we deliberately does not check whether SSRC really changed.
   // We trust caller to perform this check. Furthermore some broken
   // implementations does not change SSRC on a new stream start.
   if (mAddress != 0 && mpOutputResource != NULL)
   {
      mpOutputResource->reset();
   }

   setValue(ssrc);
}

#endif  // _MprRtpDispatcher_h_