/*
* Copyright (C) 2002-2003 Fhg Fokus
*
* This file is part of SEMS, a free SIP media server.
*
* SEMS is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. This program is released under
* the GPL with the additional exemption that compiling, linking,
* and/or using OpenSSL is allowed.
*
* For a license to use the SEMS software under conditions
* other than those described here, or to purchase support for this
* software, please contact iptel.org by e-mail at the following addresses:
* info@iptel.org
*
* SEMS 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/** @file AmRtpStream.h */
#ifndef _RtpStream_h_
#define _RtpStream_h_
#include "AmSdp.h"
#include "AmThread.h"
#include "SampleArray.h"
#include "AmRtpPacket.h"
#include "AmEvent.h"
#include <netinet/in.h>
#include <string>
#include <map>
#include <queue>
#include <memory>
using std::string;
using std::auto_ptr;
using std::pair;
// return values of AmRtpStream::receive
#define RTP_EMPTY 0 // no rtp packet available
#define RTP_PARSE_ERROR -1 // error while parsing rtp packet
#define RTP_TIMEOUT -2 // last received packet is too old
#define RTP_DTMF -3 // dtmf packet has been received
#define RTP_BUFFER_SIZE -4 // buffer overrun
#define RTP_UNKNOWN_PL -5 // unknown payload
struct amci_payload_t;
class AmAudio;
class AmSession;
struct SdpPayload;
typedef std::map<unsigned int, AmRtpPacket*, ts_less> ReceiveBuffer;
typedef std::queue<AmRtpPacket*> RtpEventQueue;
/**
* This provides the memory for the receive buffer.
*/
struct PacketMem {
#define MAX_PACKETS 32
AmRtpPacket packets[MAX_PACKETS];
bool used[MAX_PACKETS];
PacketMem();
inline AmRtpPacket* newPacket();
inline void freePacket(AmRtpPacket* p);
inline void clear();
};
/**
* \brief RTP implementation
*
* Rtp stream high level interface.
*/
class AmRtpStream
{
protected:
/**
Remote payload (only different from
int_payload if using dynamic payloads)
*/
int payload;
unsigned int sequence;
/**
Payload of last received packet.
Usefull to detect talk spurt, looking
for comfort noise packets.
*/
int last_payload;
string r_host;
unsigned short r_port;
/* local interface */
int l_if;
#ifdef SUPPORT_IPV6
struct sockaddr_storage r_saddr;
struct sockaddr_storage l_saddr;
#else
struct sockaddr_in r_saddr;
struct sockaddr_in l_saddr;
#endif
unsigned short l_port;
int l_sd;
struct timeval last_recv_time;
unsigned int l_ssrc;
unsigned int r_ssrc;
bool r_ssrc_i;
/** symmetric RTP */
bool passive; // passive mode ?
/** Payload type for telephone event */
auto_ptr<const SdpPayload> telephone_event_pt;
PacketMem mem;
ReceiveBuffer receive_buf;
RtpEventQueue rtp_ev_qu;
AmMutex receive_mut;
/** if relay_stream is initialized, received RTP is relayed there */
bool relay_enabled;
/** pointer to relay stream.
NOTE: This may only be accessed in initialization
or by the AmRtpReceiver thread while relaying! */
AmRtpStream* relay_stream;
/* get next packet in buffer */
int nextPacket(AmRtpPacket*& p);
AmSession* session;
int compile_and_send(const int payload, bool marker,
unsigned int ts, unsigned char* buffer,
unsigned int size);
void sendDtmfPacket(unsigned int ts);
// event, duration
std::queue<pair<int, unsigned int> > dtmf_send_queue;
AmMutex dtmf_send_queue_mut;
enum dtmf_sending_state_t {
DTMF_SEND_NONE, // not sending event
DTMF_SEND_SENDING, // sending event
DTMF_SEND_ENDING // sending end of event
} dtmf_sending_state;
pair<int, unsigned int> current_send_dtmf;
unsigned int current_send_dtmf_ts;
int send_dtmf_end_repeat;
/** handle symmetric RTP - if in passive mode, update raddr from rp */
void handleSymmetricRtp(AmRtpPacket* rp);
void relay(AmRtpPacket* p);
public:
AmRtpPacket* newPacket();
void freePacket(AmRtpPacket* p);
/** Mute */
bool mute;
/** mute && port == 0 */
bool hold;
/** marker flag */
bool begin_talk;
/** do check rtp timeout */
bool monitor_rtp_timeout;
/** should we receive packets? if not -> drop */
bool receiving;
int send( unsigned int ts,
unsigned char* buffer,
unsigned int size );
int send_raw( char* packet, unsigned int length );
int receive( unsigned char* buffer, unsigned int size,
unsigned int& ts, int& payload);
/** ping the remote side, to open NATs and enable symmetric RTP */
int ping();
/** Allocates resources for future use of RTP. */
AmRtpStream(AmSession* _s, int _if);
/** Stops the stream and frees all resources. */
virtual ~AmRtpStream();
/** returns the socket descriptor for local socket (initialized or not) */
int hasLocalSocket();
/** initializes and gets the socket descriptor for local socket */
int getLocalSocket();
/**
* This function must be called before setLocalPort, because
* setLocalPort will bind the socket and it will be not
* possible to change the IP later
*/
void setLocalIP(const string& ip);
/** Initializes a new random local port, and sets own attributes properly. */
void setLocalPort();
/**
* Gets RTP port number. If no RTP port in assigned, assigns a new one.
* @return local RTP port.
*/
int getLocalPort();
/**
* Gets remote RTP port.
* @return remote RTP port.
*/
int getRPort();
/**
* Gets remote host IP.
* @return remote host IP.
*/
string getRHost();
/**
* Set remote IP & port.
*/
void setRAddr(const string& addr, unsigned short port);
/** Symmetric RTP: passive mode ? */
void setPassiveMode(bool p) { passive = p; }
bool getPassiveMode() { return passive; }
unsigned int get_ssrc() { return l_ssrc; }
/**
* Set remote telephone event
* payload type
*/
void setTelephoneEventPT(const SdpPayload *pt) {
telephone_event_pt.reset(pt);
}
int getTelephoneEventRate();
/**
* send a DTMF as RTP payload (RFC4733)
* @param event event ID (e.g. key press), see rfc
* @param duration_ms duration in milliseconds
*/
void sendDtmf(int event, unsigned int duration_ms);
/**
* Enables RTP stream.
* @param sdp_payload payload from the SDP message.
* @warning start() must have been called so that play and record work.
* @warning It should be called only if the stream has been completly initialized,
* @warning and only once per session. Use resume() then.
*/
virtual void init(const vector<SdpPayload*>& sdp_payloads);
/**
* Stops RTP stream.
*/
void pause();
/**
* Resume a paused RTP stream.
*/
void resume();
/** set the RTP stream on hold (mute && port = 0) */
void setOnHold(bool on_hold);
/** get the RTP stream on hold */
bool getOnHold();
/** setter for monitor_rtp_timeout */
void setMonitorRTPTimeout(bool m) { monitor_rtp_timeout = m; }
/** getter for monitor_rtp_timeout */
bool getMonitorRTPTimeout() { return monitor_rtp_timeout; }
/**
* Insert an RTP packet to the buffer.
* Note: memory is owned by this instance.
*/
void bufferPacket(AmRtpPacket* p);
/*
* clear RTP timeout at time recv_time
*/
void clearRTPTimeout(struct timeval* recv_time);
virtual unsigned int bytes2samples(unsigned int) const;
/** set relay stream for RTP relaying */
void setRelayStream(AmRtpStream* stream);
/** ensable RTP relaying through relay stream */
void enableRtpRelay();
/** disable RTP relaying through relay stream */
void disableRtpRelay();
};
/** \brief event fired on RTP timeout */
class AmRtpTimeoutEvent
: public AmEvent
{
public:
AmRtpTimeoutEvent()
: AmEvent(0) { }
~AmRtpTimeoutEvent() { }
};
#endif
// Local Variables:
// mode:C++
// End: