mirror of https://github.com/sipwise/sems.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
341 lines
8.3 KiB
341 lines
8.3 KiB
/*
|
|
* 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:
|
|
|