MNRTPcallback.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MNRTP_CALLBACK_H
#define MNRTP_CALLBACK_H

#include "MNRTPdefs.h"
#include "../sh/SHReport.h"
#include "MNRTPPacket.h"
#include "MNValid.h"
#include <stdio.h>

class MNRTPcallback;
class MNRTCPPacket;


typedef MNRTPcallback* MNRTPcallback_p;

/**********************************************************************/
/* MNRTP_RTPreader_callback                                           */
/**********************************************************************/

class MNRTP_RTPreader_callback
{
public:
    virtual void RTPreader_cb( MNRTPPacketPtr packet ) = 0;
};

/**********************************************************************/
/* MNRTP_RTCPreader_callback                                          */
/**********************************************************************/

class MNRTP_RTCPreader_callback
{
public:
  virtual void     RTCPreader_cb( u_int32 ssrc,
                                  char*   data,
                                  int     len,
                                  int     subtype,
                                  char*   name );
 virtual void     RTCPreader_cb( SH::RPtr<MNRTCPPacket> packet );

};

/**********************************************************************/
/* MNRTP_RTCPbye_callback                                             */
/**********************************************************************/

class MNRTP_RTCPbye_callback
{
public:
  virtual void     RTCPbye_cb( u_int32      ssrc,
                               text_item_t* bye_text) = 0;
};

/**********************************************************************/
/* MNRTP_Collision_callback                                           */
/**********************************************************************/

class MNRTP_Collision_callback
{
public:
  virtual void     RTPcollission_cb( struct sockaddr_in *dest ) = 0;
};

/**********************************************************************/
/* MNRTP_CollisionApp_callback                                        */
/**********************************************************************/

class MNRTP_CollisionApp_callback
{
public:
    virtual void     RTPcollission_app_cb( u_int32 old_ssrc,
                                           u_int32 new_ssrc ) = 0;
};


/**********************************************************************/
/* MNRTPcallback                                                      */
/**********************************************************************/

class MNRTPcallback
{
    DECLARE_VALID
private:
    MNRTP_Collision_callback*    RTPcoll;
    MNRTP_CollisionApp_callback* RTPcollapp;
    MNRTP_RTPreader_callback*    RTPreadercoll;
    MNRTP_RTCPreader_callback*   RTCPreadercoll;
    MNRTP_RTCPbye_callback*      RTCPbyecoll;

public:
    MNRTPcallback()
    {
        RTPcoll        = NULL;
        RTPreadercoll  = NULL;
        RTCPreadercoll = NULL;
        RTCPbyecoll    = NULL;
        RTPcollapp     = NULL;
        MAKE_VALID
    } 

    virtual ~MNRTPcallback()
    {
        CHECK_VALID
        MAKE_INVALID
    }

    /*------------------------------------------------------------
     * The registration functions first.
     */

    void register_RTPcollission_cb( MNRTP_Collision_callback* p );
    void register_RTPcollission_app_cb( MNRTP_CollisionApp_callback* p );
    void register_RTPreader_cb(MNRTP_RTPreader_callback* p);
    void register_RTCPreader_cb(MNRTP_RTCPreader_callback* p);
    void register_RTCPbye_cb(MNRTP_RTCPbye_callback* p);

    /*------------------------------------------------------------
     * The functions that do the calling next.
     */

    /* RTP collission */
    void RTPcollission( struct sockaddr_in *dest )
    {
        CHECK_VALID
        if (RTPcoll !=NULL) RTPcoll->RTPcollission_cb(dest);
    }

    /* RTP collission application callback */
    void RTPcollission_app_call( u_int32 os, u_int32 ns )
    {
        CHECK_VALID
        if (RTPcollapp != NULL) RTPcollapp->RTPcollission_app_cb(os, ns);
    }

    void RTPreader_call( MNRTPPacketPtr packet );

    void RTCPreader_call( SH::RPtr<MNRTCPPacket> packet );

    void RTCPreader_call( u_int32 ssrc,
                          char*   data,
                          int     len,
                          int     subtype,
                          char*   name )
    {
        CHECK_VALID
        if (RTCPreadercoll !=NULL)
        {
            RTCPreadercoll->RTCPreader_cb(ssrc, data, len, subtype, name);
        }
    }

    void RTCPbye_call(u_int32 ssrc, text_item_t *bye_text)
    {
        CHECK_VALID
        if (RTCPbyecoll != NULL) RTCPbyecoll->RTCPbye_cb(ssrc, bye_text);
    }

}; // class MNRTPcallback()

#endif

---