/*

 This file is a part of JRTPLIB
 Copyright (c) 1999-2017 Jori Liesenborgs

 Contact: jori.liesenborgs@gmail.com

 This library was developed at the Expertise Centre for Digital Media
 (http://www.edm.uhasselt.be), a research center of the Hasselt University
 (http://www.uhasselt.be). The library is based upon work done for
 my thesis at the School for Knowledge Technology (Belgium/The Netherlands).

 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),
 to deal in the Software without restriction, including without limitation
 the rights to use, copy, modify, merge, publish, distribute, sublicense,
 and/or sell copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included
 in all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 IN THE SOFTWARE.

 */

/**
 * \file rtpsession.h
 */

#ifndef RTPSESSION_H

#define RTPSESSION_H

#include "rtpconfig.h"
#include "rtppacketbuilder.h"
#include "rtpsessionsources.h"
#include "rtptransmitter.h"
#include "rtpcollisionlist.h"
#include "rtcpscheduler.h"
#include "rtcppacketbuilder.h"
#include "rtptimeutilities.h"
#include <list>

#include "export.h"

namespace qrtplib
{

class RTPTransmitter;
class RTPSessionParams;
class RTPTransmissionParams;
class RTPAddress;
class RTPSourceData;
class RTPPacket;
class RTPPollThread;
class RTPTransmissionInfo;
class RTCPCompoundPacket;
class RTCPPacket;
class RTCPAPPPacket;

/** High level class for using RTP.
 *  For most RTP based applications, the RTPSession class will probably be the one to use. It handles
 *  the RTCP part completely internally, so the user can focus on sending and receiving the actual data.
 *  In case you want to use SRTP, you should create an RTPSecureSession derived class.
 *  \note The RTPSession class is not meant to be thread safe. The user should use some kind of locking
 *        mechanism to prevent different threads from using the same RTPSession instance.
 */
class QRTPLIB_API RTPSession
{
public:
    /** Constructs an RTPSession instance, optionally using a specific instance of a random
     *  number generator, and optionally installing a memory manager.
     *  Constructs an RTPSession instance, optionally using a specific instance of a random
     *  number generator, and optionally installing a memory manager. If no random number generator
     *  is specified, the RTPSession object will try to use either a RTPRandomURandom or
     *  RTPRandomRandS instance. If neither is available on the current platform, a RTPRandomRand48
     *  instance will be used instead. By specifying a random number generator yourself, it is
     *  possible to use the same generator in several RTPSession instances.
     */
    RTPSession(RTPRandom *rnd = 0);
    virtual ~RTPSession();

    /** Creates an RTP session.
     *  This function creates an RTP session with parameters \c sessparams, which will use a transmitter
     *  corresponding to \c proto. Parameters for this transmitter can be specified as well. If \c
     *  proto is of type RTPTransmitter::UserDefinedProto, the NewUserDefinedTransmitter function must
     *  be implemented.
     */
    //int Create(const RTPSessionParams &sessparams, const RTPTransmissionParams *transparams = 0, RTPTransmitter::TransmissionProtocol proto = RTPTransmitter::IPv4UDPProto);

    /** Creates an RTP session using \c transmitter as transmission component.
     *  This function creates an RTP session with parameters \c sessparams, which will use the
     *  transmission component \c transmitter. Initialization and destruction of the transmitter
     *  will not be done by the RTPSession class if this Create function is used. This function
     *  can be useful if you which to reuse the transmission component in another RTPSession
     *  instance, once the original RTPSession isn't using the transmitter anymore.
     */
    int Create(const RTPSessionParams &sessparams, RTPTransmitter *transmitter);

    /** Leaves the session without sending a BYE packet. */
    void Destroy();

    /** Sends a BYE packet and leaves the session.
     *  Sends a BYE packet and leaves the session. At most a time \c maxwaittime will be waited to
     *  send the BYE packet. If this time expires, the session will be left without sending a BYE packet.
     *  The BYE packet will contain as reason for leaving \c reason with length \c reasonlength.
     */
    void BYEDestroy(const RTPTime &maxwaittime, const void *reason, std::size_t reasonlength);

    /** Returns whether the session has been created or not. */
    bool IsActive();

    /** Returns our own SSRC. */
    uint32_t GetLocalSSRC();

    /** Adds \c addr to the list of destinations. */
    int AddDestination(const RTPAddress &addr);

    /** Deletes \c addr from the list of destinations. */
    int DeleteDestination(const RTPAddress &addr);

    /** Clears the list of destinations. */
    void ClearDestinations();

    /** Returns \c true if multicasting is supported. */
    bool SupportsMulticasting();

    /** Joins the multicast group specified by \c addr. */
    int JoinMulticastGroup(const RTPAddress &addr);

    /** Leaves the multicast group specified by \c addr. */
    int LeaveMulticastGroup(const RTPAddress &addr);

    /** Sends the RTP packet with payload \c data which has length \c len.
     *  Sends the RTP packet with payload \c data which has length \c len.
     *  The used payload type, marker and timestamp increment will be those that have been set
     *  using the \c SetDefault member functions.
     */
    int SendPacket(const void *data, std::size_t len);

    /** Sends the RTP packet with payload \c data which has length \c len.
     *  It will use payload type \c pt, marker \c mark and after the packet has been built, the
     *  timestamp will be incremented by \c timestampinc.
     */
    int SendPacket(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc);

    /** Sends the RTP packet with payload \c data which has length \c len.
     *  The packet will contain a header extension with identifier \c hdrextID and containing data
     *  \c hdrextdata. The length of this data is given by \c numhdrextwords and is specified in a
     *  number of 32-bit words. The used payload type, marker and timestamp increment will be those that
     *  have been set using the \c SetDefault member functions.
     */
    int SendPacketEx(const void *data, std::size_t len, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords);

    /** Sends the RTP packet with payload \c data which has length \c len.
     *  It will use payload type \c pt, marker \c mark and after the packet has been built, the
     *  timestamp will be incremented by \c timestampinc. The packet will contain a header
     *  extension with identifier \c hdrextID and containing data \c hdrextdata. The length
     *  of this data is given by \c numhdrextwords and is specified in a number of 32-bit words.
     */
    int SendPacketEx(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords);
#ifdef RTP_SUPPORT_SENDAPP
    /** If sending of RTCP APP packets was enabled at compile time, this function creates a compound packet
     *  containing an RTCP APP packet and sends it immediately.
     *  If sending of RTCP APP packets was enabled at compile time, this function creates a compound packet
     *  containing an RTCP APP packet and sends it immediately. If successful, the function returns the number
     *  of bytes in the RTCP compound packet. Note that this immediate sending is not compliant with the RTP
     *  specification, so use with care.
     */
    int SendRTCPAPPPacket(uint8_t subtype, const uint8_t name[4], const void *appdata, std::size_t appdatalen);
#endif // RTP_SUPPORT_SENDAPP

    /** With this function raw data can be sent directly over the RTP or
     *  RTCP channel (if they are different); the data is **not** passed through the
     *  RTPSession::OnChangeRTPOrRTCPData function. */
    int SendRawData(const void *data, std::size_t len, bool usertpchannel);

    /** Sets the default payload type for RTP packets to \c pt. */
    int SetDefaultPayloadType(uint8_t pt);

    /** Sets the default marker for RTP packets to \c m. */
    int SetDefaultMark(bool m);

    /** Sets the default value to increment the timestamp with to \c timestampinc. */
    int SetDefaultTimestampIncrement(uint32_t timestampinc);

    /** This function increments the timestamp with the amount given by \c inc.
     *  This function increments the timestamp with the amount given by \c inc. This can be useful
     *  if, for example, a packet was not sent because it contained only silence. Then, this function
     *  should be called to increment the timestamp with the appropriate amount so that the next packets
     *  will still be played at the correct time at other hosts.
     */
    int IncrementTimestamp(uint32_t inc);

    /** This function increments the timestamp with the amount given set by the SetDefaultTimestampIncrement
     *  member function.
     *  This function increments the timestamp with the amount given set by the SetDefaultTimestampIncrement
     *  member function. This can be useful if, for example, a packet was not sent because it contained only silence.
     *  Then, this function should be called to increment the timestamp with the appropriate amount so that the next
     *  packets will still be played at the correct time at other hosts.
     */
    int IncrementTimestampDefault();

    /** This function allows you to inform the library about the delay between sampling the first
     *  sample of a packet and sending the packet.
     *  This function allows you to inform the library about the delay between sampling the first
     *  sample of a packet and sending the packet. This delay is taken into account when calculating the
     *  relation between RTP timestamp and wallclock time, used for inter-media synchronization.
     */
    int SetPreTransmissionDelay(const RTPTime &delay);

    /** This function returns an instance of a subclass of RTPTransmissionInfo which will give some
     *  additional information about the transmitter (a list of local IP addresses for example).
     *  This function returns an instance of a subclass of RTPTransmissionInfo which will give some
     *  additional information about the transmitter (a list of local IP addresses for example). The user
     *  has to free the returned instance when it is no longer needed, preferably using the DeleteTransmissionInfo
     *  function.
     */
    RTPTransmissionInfo *GetTransmissionInfo();

    /** Frees the memory used by the transmission information \c inf. */
    void DeleteTransmissionInfo(RTPTransmissionInfo *inf);

    /** Returns the time interval after which an RTCP compound packet may have to be sent (only works when
     *  you're not using the poll thread.
     */
    RTPTime GetRTCPDelay();

    /** The following member functions (till EndDataAccess}) need to be accessed between a call
     *  to BeginDataAccess and EndDataAccess.
     *  The BeginDataAccess function makes sure that the poll thread won't access the source table
     *  at the same time that you're using it. When the EndDataAccess is called, the lock on the
     *  source table is freed again.
     */
    int BeginDataAccess();

    /** Starts the iteration over the participants by going to the first member in the table.
     *  Starts the iteration over the participants by going to the first member in the table.
     *  If a member was found, the function returns \c true, otherwise it returns \c false.
     */
    bool GotoFirstSource();

    /** Sets the current source to be the next source in the table.
     *  Sets the current source to be the next source in the table. If we're already at the last
     *  source, the function returns \c false, otherwise it returns \c true.
     */
    bool GotoNextSource();

    /** Sets the current source to be the previous source in the table.
     *  Sets the current source to be the previous source in the table. If we're at the first source,
     *  the function returns \c false, otherwise it returns \c true.
     */
    bool GotoPreviousSource();

    /** Sets the current source to be the first source in the table which has RTPPacket instances
     *  that we haven't extracted yet.
     *  Sets the current source to be the first source in the table which has RTPPacket instances
     *  that we haven't extracted yet. If no such member was found, the function returns \c false,
     *  otherwise it returns \c true.
     */
    bool GotoFirstSourceWithData();

    /** Sets the current source to be the next source in the table which has RTPPacket instances
     *  that we haven't extracted yet.
     *  Sets the current source to be the next source in the table which has RTPPacket instances
     *  that we haven't extracted yet. If no such member was found, the function returns \c false,
     *  otherwise it returns \c true.
     */
    bool GotoNextSourceWithData();

    /** Sets the current source to be the previous source in the table which has RTPPacket
     *  instances that we haven't extracted yet.
     *  Sets the current source to be the previous source in the table which has RTPPacket
     *  instances that we haven't extracted yet. If no such member was found, the function returns \c false,
     *  otherwise it returns \c true.
     */
    bool GotoPreviousSourceWithData();

    /** Returns the \c RTPSourceData instance for the currently selected participant. */
    RTPSourceData *GetCurrentSourceInfo();

    /** Returns the \c RTPSourceData instance for the participant identified by \c ssrc,
     *  or NULL if no such entry exists.
     */
    RTPSourceData *GetSourceInfo(uint32_t ssrc);

    /** Extracts the next packet from the received packets queue of the current participant,
     *  or NULL if no more packets are available.
     *  Extracts the next packet from the received packets queue of the current participant,
     *  or NULL if no more packets are available. When the packet is no longer needed, its
     *  memory should be freed using the DeletePacket member function.
     */
    RTPPacket *GetNextPacket();

    /** Returns the Sequence Number that will be used in the next SendPacket function call. */
    uint16_t GetNextSequenceNumber() const;

    /** Frees the memory used by \c p. */
    void DeletePacket(RTPPacket *p);

    /** See BeginDataAccess. */
    int EndDataAccess();

    /** Sets the receive mode to \c m.
     *  Sets the receive mode to \c m. Note that when the receive mode is changed, the list of
     *  addresses to be ignored ot accepted will be cleared.
     */
    int SetReceiveMode(RTPTransmitter::ReceiveMode m);

    /** Adds \c addr to the list of addresses to ignore. */
    int AddToIgnoreList(const RTPAddress &addr);

    /** Deletes \c addr from the list of addresses to ignore. */
    int DeleteFromIgnoreList(const RTPAddress &addr);

    /** Clears the list of addresses to ignore. */
    void ClearIgnoreList();

    /** Adds \c addr to the list of addresses to accept. */
    int AddToAcceptList(const RTPAddress &addr);

    /** Deletes \c addr from the list of addresses to accept. */
    int DeleteFromAcceptList(const RTPAddress &addr);

    /** Clears the list of addresses to accept. */
    void ClearAcceptList();

    /** Sets the maximum allowed packet size to \c s. */
    int SetMaximumPacketSize(std::size_t s);

    /** Sets the session bandwidth to \c bw, which is specified in bytes per second. */
    int SetSessionBandwidth(double bw);

    /** Sets the timestamp unit for our own data.
     *  Sets the timestamp unit for our own data. The timestamp unit is defined as a time interval in
     *  seconds divided by the corresponding timestamp interval. For example, for 8000 Hz audio, the
     *  timestamp unit would typically be 1/8000. Since this value is initially set to an illegal value,
     *  the user must set this to an allowed value to be able to create a session.
     */
    int SetTimestampUnit(double u);

    /** Sets the RTCP interval for the SDES name item.
     *  After all possible sources in the source table have been processed, the class will check if other
     *  SDES items need to be sent. If \c count is zero or negative, nothing will happen. If \c count
     *  is positive, an SDES name item will be added after the sources in the source table have been
     *  processed \c count times.
     */
    void SetNameInterval(int count);

    /** Sets the RTCP interval for the SDES e-mail item.
     *  After all possible sources in the source table have been processed, the class will check if other
     *  SDES items need to be sent. If \c count is zero or negative, nothing will happen. If \c count
     *  is positive, an SDES e-mail item will be added after the sources in the source table have been
     *  processed \c count times.
     */
    void SetEMailInterval(int count);

    /** Sets the RTCP interval for the SDES location item.
     *  After all possible sources in the source table have been processed, the class will check if other
     *  SDES items need to be sent. If \c count is zero or negative, nothing will happen. If \c count
     *  is positive, an SDES location item will be added after the sources in the source table have been
     *  processed \c count times.
     */
    void SetLocationInterval(int count);

    /** Sets the RTCP interval for the SDES phone item.
     *  After all possible sources in the source table have been processed, the class will check if other
     *  SDES items need to be sent. If \c count is zero or negative, nothing will happen. If \c count
     *  is positive, an SDES phone item will be added after the sources in the source table have been
     *  processed \c count times.
     */
    void SetPhoneInterval(int count);

    /** Sets the RTCP interval for the SDES tool item.
     *  After all possible sources in the source table have been processed, the class will check if other
     *  SDES items need to be sent. If \c count is zero or negative, nothing will happen. If \c count
     *  is positive, an SDES tool item will be added after the sources in the source table have been
     *  processed \c count times.
     */
    void SetToolInterval(int count);

    /** Sets the RTCP interval for the SDES note item.
     *  After all possible sources in the source table have been processed, the class will check if other
     *  SDES items need to be sent. If \c count is zero or negative, nothing will happen. If \c count
     *  is positive, an SDES note item will be added after the sources in the source table have been
     *  processed \c count times.
     */
    void SetNoteInterval(int count);

    /** Sets the SDES name item for the local participant to the value \c s with length \c len. */
    int SetLocalName(const void *s, std::size_t len);

    /** Sets the SDES e-mail item for the local participant to the value \c s with length \c len. */
    int SetLocalEMail(const void *s, std::size_t len);

    /** Sets the SDES location item for the local participant to the value \c s with length \c len. */
    int SetLocalLocation(const void *s, std::size_t len);

    /** Sets the SDES phone item for the local participant to the value \c s with length \c len. */
    int SetLocalPhone(const void *s, std::size_t len);

    /** Sets the SDES tool item for the local participant to the value \c s with length \c len. */
    int SetLocalTool(const void *s, std::size_t len);

    /** Sets the SDES note item for the local participant to the value \c s with length \c len. */
    int SetLocalNote(const void *s, std::size_t len);

protected:
    /** Allocate a user defined transmitter.
     *  In case you specified in the Create function that you want to use a
     *  user defined transmitter, you should override this function. The RTPTransmitter
     *  instance returned by this function will then be used to send and receive RTP and
     *  RTCP packets. Note that when the session is destroyed, this RTPTransmitter
     *  instance will be destroyed as well.
     */
    virtual RTPTransmitter *NewUserDefinedTransmitter();

    /** Is called when an incoming RTP packet is about to be processed.
     *  Is called when an incoming RTP packet is about to be processed. This is _not_
     *  a good function to process an RTP packet in, in case you want to avoid iterating
     *  over the sources using the GotoFirst/GotoNext functions. In that case, the
     *  RTPSession::OnValidatedRTPPacket function should be used.
     */
    virtual void OnRTPPacket(RTPPacket *pack, const RTPTime &receivetime, const RTPAddress *senderaddress);

    /** Is called when an incoming RTCP packet is about to be processed. */
    virtual void OnRTCPCompoundPacket(RTCPCompoundPacket *pack, const RTPTime &receivetime, const RTPAddress *senderaddress);

    /** Is called when an SSRC collision was detected.
     *  Is called when an SSRC collision was detected. The instance \c srcdat is the one present in
     *  the table, the address \c senderaddress is the one that collided with one of the addresses
     *  and \c isrtp indicates against which address of \c srcdat the check failed.
     */
    virtual void OnSSRCCollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, bool isrtp);

    /** Is called when another CNAME was received than the one already present for source \c srcdat. */
    virtual void OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, std::size_t cnamelength);

    /** Is called when a new entry \c srcdat is added to the source table. */
    virtual void OnNewSource(RTPSourceData *srcdat);

    /** Is called when the entry \c srcdat is about to be deleted from the source table. */
    virtual void OnRemoveSource(RTPSourceData *srcdat);

    /** Is called when participant \c srcdat is timed out. */
    virtual void OnTimeout(RTPSourceData *srcdat);

    /** Is called when participant \c srcdat is timed after having sent a BYE packet. */
    virtual void OnBYETimeout(RTPSourceData *srcdat);

    /** Is called when an RTCP APP packet \c apppacket has been received at time \c receivetime
     *  from address \c senderaddress.
     */
    virtual void OnAPPPacket(RTCPAPPPacket *apppacket, const RTPTime &receivetime, const RTPAddress *senderaddress);

    /** Is called when an unknown RTCP packet type was detected. */
    virtual void OnUnknownPacketType(RTCPPacket *rtcppack, const RTPTime &receivetime, const RTPAddress *senderaddress);

    /** Is called when an unknown packet format for a known packet type was detected. */
    virtual void OnUnknownPacketFormat(RTCPPacket *rtcppack, const RTPTime &receivetime, const RTPAddress *senderaddress);

    /** Is called when the SDES NOTE item for source \c srcdat has been timed out. */
    virtual void OnNoteTimeout(RTPSourceData *srcdat);

    /** Is called when an RTCP sender report has been processed for this source. */
    virtual void OnRTCPSenderReport(RTPSourceData *srcdat);

    /** Is called when an RTCP receiver report has been processed for this source. */
    virtual void OnRTCPReceiverReport(RTPSourceData *srcdat);

    /** Is called when a specific SDES item was received for this source. */
    virtual void OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, std::size_t itemlength);
#ifdef RTP_SUPPORT_SDESPRIV
    /** Is called when a specific SDES item of 'private' type was received for this source. */
    virtual void OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, std::size_t prefixlen, const void *valuedata, std::size_t valuelen);
#endif // RTP_SUPPORT_SDESPRIV

    /** Is called when a BYE packet has been processed for source \c srcdat. */
    virtual void OnBYEPacket(RTPSourceData *srcdat);

    /** Is called when an RTCP compound packet has just been sent (useful to inspect outgoing RTCP data). */
    virtual void OnSendRTCPCompoundPacket(RTCPCompoundPacket *pack);

    /** If this is set to true, outgoing data will be passed through RTPSession::OnChangeRTPOrRTCPData
     *  and RTPSession::OnSentRTPOrRTCPData, allowing you to modify the data (e.g. to encrypt it). */
    void SetChangeOutgoingData(bool change)
    {
        m_changeOutgoingData = change;
    }

    /** If this is set to true, incoming data will be passed through RTPSession::OnChangeIncomingData,
     *  allowing you to modify the data (e.g. to decrypt it). */
    void SetChangeIncomingData(bool change)
    {
        m_changeIncomingData = change;
    }

    /** If RTPSession::SetChangeOutgoingData was sent to true, overriding this you can change the
     *  data packet that will actually be sent, for example adding encryption.
     *  If RTPSession::SetChangeOutgoingData was sent to true, overriding this you can change the
     *  data packet that will actually be sent, for example adding encryption.
     *  Note that no memory management will be performed on the `senddata` pointer you fill in,
     *  so if it needs to be deleted at some point you need to take care of this in some way
     *  yourself, a good way may be to do this in RTPSession::OnSentRTPOrRTCPData. If `senddata` is
     *  set to 0, no packet will be sent out. This also provides a way to turn off sending RTCP
     *  packets if desired. */
    virtual int OnChangeRTPOrRTCPData(const void *origdata, std::size_t origlen, bool isrtp, void **senddata, std::size_t *sendlen);

    /** This function is called when an RTP or RTCP packet was sent, it can be helpful
     *  when data was allocated in RTPSession::OnChangeRTPOrRTCPData to deallocate it
     *  here. */
    virtual void OnSentRTPOrRTCPData(void *senddata, std::size_t sendlen, bool isrtp);

    /** By overriding this function, the raw incoming data can be inspected
     *  and modified (e.g. for encryption).
     *  By overriding this function, the raw incoming data can be inspected
     *  and modified (e.g. for encryption). If the function returns `false`,
     *  the packet is discarded.
     */
    virtual bool OnChangeIncomingData(RTPRawPacket *rawpack);

    /** Allows you to use an RTP packet from the specified source directly.
     *  Allows you to use an RTP packet from the specified source directly. If
     *  `ispackethandled` is set to `true`, the packet will no longer be stored in this
     *  source's packet list. Note that if you do set this flag, you'll need to
     *  deallocate the packet yourself at an appropriate time.
     *
     *  The difference with RTPSession::OnRTPPacket is that that
     *  function will always process the RTP packet further and is therefore not
     *  really suited to actually do something with the data.
     */
    virtual void OnValidatedRTPPacket(RTPSourceData *srcdat, RTPPacket *rtppack, bool isonprobation, bool *ispackethandled);
private:
    int InternalCreate(const RTPSessionParams &sessparams);
    int CreateCNAME(uint8_t *buffer, std::size_t *bufferlength, bool resolve);
    int ProcessPolledData();
    int ProcessRTCPCompoundPacket(RTCPCompoundPacket &rtcpcomppack, RTPRawPacket *pack);
    RTPRandom *GetRandomNumberGenerator(RTPRandom *r);
    int SendRTPData(const void *data, std::size_t len);
    int SendRTCPData(const void *data, std::size_t len);

    RTPRandom *rtprnd;
    bool deletertprnd;

    RTPTransmitter *rtptrans;
    bool created;
    bool deletetransmitter;
    bool usingpollthread;
    bool acceptownpackets;
    bool useSR_BYEifpossible;
    std::size_t maxpacksize;
    double sessionbandwidth;
    double controlfragment;
    double sendermultiplier;
    double byemultiplier;
    double membermultiplier;
    double collisionmultiplier;
    double notemultiplier;
    bool sentpackets;

    bool m_changeIncomingData, m_changeOutgoingData;

    RTPSessionSources sources;
    RTPPacketBuilder packetbuilder;
    RTCPScheduler rtcpsched;
    RTCPPacketBuilder rtcpbuilder;
    RTPCollisionList collisionlist;

    std::list<RTCPCompoundPacket *> byepackets;

    friend class RTPSessionSources;
    friend class RTCPSessionPacketBuilder;
};

inline RTPTransmitter *RTPSession::NewUserDefinedTransmitter()
{
    return 0;
}
inline void RTPSession::OnRTPPacket(RTPPacket *, const RTPTime &, const RTPAddress *)
{
}
inline void RTPSession::OnRTCPCompoundPacket(RTCPCompoundPacket *, const RTPTime &, const RTPAddress *)
{
}
inline void RTPSession::OnSSRCCollision(RTPSourceData *, const RTPAddress *, bool)
{
}
inline void RTPSession::OnCNAMECollision(RTPSourceData *, const RTPAddress *, const uint8_t *, std::size_t)
{
}
inline void RTPSession::OnNewSource(RTPSourceData *)
{
}
inline void RTPSession::OnRemoveSource(RTPSourceData *)
{
}
inline void RTPSession::OnTimeout(RTPSourceData *)
{
}
inline void RTPSession::OnBYETimeout(RTPSourceData *)
{
}
inline void RTPSession::OnAPPPacket(RTCPAPPPacket *, const RTPTime &, const RTPAddress *)
{
}
inline void RTPSession::OnUnknownPacketType(RTCPPacket *, const RTPTime &, const RTPAddress *)
{
}
inline void RTPSession::OnUnknownPacketFormat(RTCPPacket *, const RTPTime &, const RTPAddress *)
{
}
inline void RTPSession::OnNoteTimeout(RTPSourceData *)
{
}
inline void RTPSession::OnRTCPSenderReport(RTPSourceData *)
{
}
inline void RTPSession::OnRTCPReceiverReport(RTPSourceData *)
{
}
inline void RTPSession::OnRTCPSDESItem(RTPSourceData *, RTCPSDESPacket::ItemType, const void *, std::size_t)
{
}

#ifdef RTP_SUPPORT_SDESPRIV
inline void RTPSession::OnRTCPSDESPrivateItem(RTPSourceData *, const void *, std::size_t, const void *, std::size_t)
{
}
#endif // RTP_SUPPORT_SDESPRIV

inline void RTPSession::OnBYEPacket(RTPSourceData *)
{
}
inline void RTPSession::OnSendRTCPCompoundPacket(RTCPCompoundPacket *)
{
}

inline int RTPSession::OnChangeRTPOrRTCPData(const void *, std::size_t, bool, void **, std::size_t *)
{
    return ERR_RTP_RTPSESSION_CHANGEREQUESTEDBUTNOTIMPLEMENTED;
}
inline void RTPSession::OnSentRTPOrRTCPData(void *, std::size_t, bool)
{
}
inline bool RTPSession::OnChangeIncomingData(RTPRawPacket *)
{
    return true;
}
inline void RTPSession::OnValidatedRTPPacket(RTPSourceData *, RTPPacket *, bool, bool *)
{
}

} // end namespace

#endif // RTPSESSION_H

