mirror of
https://github.com/mpv-player/mpv
synced 2025-01-20 21:07:29 +01:00
added new native rtsp demuxer code for mpeg-ts over rtp (now both real and non-real servers should be handled)
git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@18833 b3059339-0415-0410-9bf9-f77b7e298cf2
This commit is contained in:
ben
parent
82853d7abd
commit
054b52cb01
@ -70,12 +70,11 @@
|
||||
{"sdp", "-sdp is obsolete, use sdp://file instead.\n", CONF_TYPE_PRINT, 0, 0, 0, NULL},
|
||||
// -rtsp-stream-over-tcp option, specifying TCP streaming of RTP/RTCP
|
||||
{"rtsp-stream-over-tcp", &rtspStreamOverTCP, CONF_TYPE_FLAG, 0, 0, 1, NULL},
|
||||
{"rtsp-port", &rtsp_port, CONF_TYPE_INT, CONF_RANGE, -1, 65535, NULL},
|
||||
#else
|
||||
{"rtsp-stream-over-tcp", "RTSP support requires the \"LIVE555 Streaming Media\" libraries.\n", CONF_TYPE_PRINT, CONF_NOCFG, 0, 0, NULL},
|
||||
{"rtsp-port", "RTSP support requires the \"LIVE555 Streaming Media\" libraries.\n", CONF_TYPE_PRINT, CONF_NOCFG, 0, 0, NULL},
|
||||
#endif
|
||||
|
||||
{"rtsp-port", &rtsp_port, CONF_TYPE_INT, CONF_RANGE, -1, 65535, NULL},
|
||||
|
||||
// ------------------------- demuxer options --------------------
|
||||
|
||||
// number of frames to play/convert
|
||||
@ -415,8 +414,8 @@ extern int flip_hebrew;
|
||||
|
||||
#ifdef STREAMING_LIVE555
|
||||
extern int rtspStreamOverTCP;
|
||||
extern int rtsp_port;
|
||||
#endif
|
||||
extern int rtsp_port;
|
||||
|
||||
|
||||
extern int audio_stream_cache;
|
||||
|
||||
@ -139,6 +139,7 @@ SRCS += realrtsp/asmrp.c \
|
||||
realrtsp/xbuffer.c \
|
||||
|
||||
SRCS += librtsp/rtsp.c \
|
||||
librtsp/rtsp_rtp.c \
|
||||
librtsp/rtsp_session.c \
|
||||
|
||||
SRCS += freesdp/common.c \
|
||||
|
||||
685
libmpdemux/librtsp/rtsp_rtp.c
Normal file
685
libmpdemux/librtsp/rtsp_rtp.c
Normal file
@ -0,0 +1,685 @@
|
||||
/*
|
||||
* Copyright (C) 2006 Benjamin Zores
|
||||
* based on the Freebox patch for xine by Vincent Mussard
|
||||
* but with many enhancements for better RTSP RFC compliance.
|
||||
*
|
||||
* This program 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 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
#include <netdb.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#ifndef HAVE_WINSOCK2
|
||||
#include <netinet/in.h>
|
||||
#include <sys/socket.h>
|
||||
#include <arpa/inet.h>
|
||||
#define closesocket close
|
||||
#else
|
||||
#include <winsock2.h>
|
||||
#include <ws2tcpip.h>
|
||||
#endif
|
||||
|
||||
#include "mp_msg.h"
|
||||
#include "rtsp.h"
|
||||
#include "rtsp_rtp.h"
|
||||
#include "rtsp_session.h"
|
||||
#include "../freesdp/common.h"
|
||||
#include "../freesdp/parser.h"
|
||||
|
||||
#define RTSP_DEFAULT_PORT 31336
|
||||
#define MAX_LENGTH 256
|
||||
|
||||
#define RTSP_ACCEPT_SDP "Accept: application/sdp"
|
||||
#define RTSP_CONTENT_LENGTH "Content-length"
|
||||
#define RTSP_CONTENT_TYPE "Content-Type"
|
||||
#define RTSP_APPLICATION_SDP "application/sdp"
|
||||
#define RTSP_RANGE "Range: "
|
||||
#define RTSP_NPT_NOW "npt=now-"
|
||||
#define RTSP_MEDIA_CONTAINER_MPEG_TS "33"
|
||||
#define RTSP_TRANSPORT_REQUEST "Transport: RTP/AVP;%s;%s%i-%i;mode=\"PLAY\""
|
||||
|
||||
#define RTSP_TRANSPORT_MULTICAST "multicast"
|
||||
#define RTSP_TRANSPORT_UNICAST "unicast"
|
||||
|
||||
#define RTSP_MULTICAST_PORT "port="
|
||||
#define RTSP_UNICAST_CLIENT_PORT "client_port="
|
||||
#define RTSP_UNICAST_SERVER_PORT "server_port="
|
||||
#define RTSP_SETUP_DESTINATION "destination="
|
||||
|
||||
#define RTSP_SESSION "Session"
|
||||
#define RTSP_TRANSPORT "Transport"
|
||||
|
||||
/* hardcoded RTCP RR - this is _NOT_ RFC compliant */
|
||||
#define RTCP_RR_SIZE 32
|
||||
#define RTCP_RR "\201\311\0\7(.JD\31+\306\343\0\0\0\0\0\0/E\0\0\2&\0\0\0\0\0\0\0\0\201"
|
||||
#define RTCP_SEND_FREQUENCY 1024
|
||||
|
||||
int rtsp_port = 0;
|
||||
|
||||
void
|
||||
rtcp_send_rr (rtsp_t *s, struct rtp_rtsp_session_t *st)
|
||||
{
|
||||
if (st->rtcp_socket == -1)
|
||||
return;
|
||||
|
||||
/* send RTCP RR every RTCP_SEND_FREQUENCY packets
|
||||
* FIXME : NOT CORRECT, HARDCODED, BUT MAKES SOME SERVERS HAPPY
|
||||
* not rfc compliant
|
||||
* http://www.faqs.org/rfcs/rfc1889.html chapter 6 for RTCP
|
||||
*/
|
||||
|
||||
if (st->count == RTCP_SEND_FREQUENCY)
|
||||
{
|
||||
char rtcp_content[RTCP_RR_SIZE];
|
||||
strcpy (rtcp_content, RTCP_RR);
|
||||
send (st->rtcp_socket, rtcp_content, RTCP_RR_SIZE, 0);
|
||||
|
||||
/* ping RTSP server to keep connection alive.
|
||||
we use OPTIONS instead of PING as not all servers support it */
|
||||
rtsp_request_options (s, "*");
|
||||
st->count = 0;
|
||||
}
|
||||
else
|
||||
st->count++;
|
||||
}
|
||||
|
||||
static struct rtp_rtsp_session_t *
|
||||
rtp_session_new (void)
|
||||
{
|
||||
struct rtp_rtsp_session_t *st = NULL;
|
||||
|
||||
st = malloc (sizeof (struct rtp_rtsp_session_t));
|
||||
|
||||
st->rtp_socket = -1;
|
||||
st->rtcp_socket = -1;
|
||||
st->control_url = NULL;
|
||||
st->count = 0;
|
||||
|
||||
return st;
|
||||
}
|
||||
|
||||
void
|
||||
rtp_session_free (struct rtp_rtsp_session_t *st)
|
||||
{
|
||||
if (!st)
|
||||
return;
|
||||
|
||||
if (st->rtp_socket != -1)
|
||||
close (st->rtp_socket);
|
||||
if (st->rtcp_socket != -1)
|
||||
close (st->rtcp_socket);
|
||||
|
||||
if (st->control_url)
|
||||
free (st->control_url);
|
||||
free (st);
|
||||
}
|
||||
|
||||
static void
|
||||
rtp_session_set_fd (struct rtp_rtsp_session_t *st,
|
||||
int rtp_sock, int rtcp_sock)
|
||||
{
|
||||
if (!st)
|
||||
return;
|
||||
|
||||
st->rtp_socket = rtp_sock;
|
||||
st->rtcp_socket = rtcp_sock;
|
||||
}
|
||||
|
||||
static int
|
||||
parse_port (const char *line, const char *param,
|
||||
int *rtp_port, int *rtcp_port)
|
||||
{
|
||||
char *parse1;
|
||||
char *parse2;
|
||||
char *parse3;
|
||||
|
||||
char *line_copy = strdup (line);
|
||||
|
||||
parse1 = strstr (line_copy, param);
|
||||
|
||||
if (parse1)
|
||||
{
|
||||
parse2 = strstr (parse1, "-");
|
||||
|
||||
if (parse2)
|
||||
{
|
||||
parse3 = strstr (parse2, ";");
|
||||
|
||||
if (parse3)
|
||||
parse3[0] = 0;
|
||||
|
||||
parse2[0] = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
free (line_copy);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
free (line_copy);
|
||||
return 0;
|
||||
}
|
||||
|
||||
*rtp_port = atoi (parse1 + strlen (param));
|
||||
*rtcp_port = atoi (parse2 + 1);
|
||||
|
||||
free (line_copy);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static char *
|
||||
parse_destination (const char *line)
|
||||
{
|
||||
char *parse1;
|
||||
char *parse2;
|
||||
|
||||
char *dest = NULL;
|
||||
char *line_copy = strdup (line);
|
||||
int len;
|
||||
|
||||
parse1 = strstr (line_copy, RTSP_SETUP_DESTINATION);
|
||||
if (!parse1)
|
||||
{
|
||||
free (line_copy);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
parse2 = strstr (parse1, ";");
|
||||
if (!parse2)
|
||||
{
|
||||
free (line_copy);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
len = strlen (parse1) - strlen (parse2)
|
||||
- strlen (RTSP_SETUP_DESTINATION) + 1;
|
||||
dest = (char *) malloc (len + 1);
|
||||
snprintf (dest, len, parse1 + strlen (RTSP_SETUP_DESTINATION));
|
||||
free (line_copy);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
static int
|
||||
rtcp_connect (int client_port, int server_port, const char* server_hostname)
|
||||
{
|
||||
struct sockaddr_in sin;
|
||||
struct hostent *hp;
|
||||
int s;
|
||||
|
||||
if (client_port <= 1023)
|
||||
return -1;
|
||||
|
||||
s = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
||||
if (s == -1)
|
||||
return -1;
|
||||
|
||||
hp = gethostbyname (server_hostname);
|
||||
if (!hp)
|
||||
{
|
||||
close (s);
|
||||
return -1;
|
||||
}
|
||||
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_addr.s_addr = INADDR_ANY;
|
||||
sin.sin_port = htons (client_port);
|
||||
|
||||
if (bind (s, (struct sockaddr *) &sin, sizeof (sin)))
|
||||
{
|
||||
#ifndef HAVE_WINSOCK2
|
||||
if (errno != EINPROGRESS)
|
||||
#else
|
||||
if (WSAGetLastError() != WSAEINPROGRESS)
|
||||
#endif
|
||||
{
|
||||
close (s);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
sin.sin_family = AF_INET;
|
||||
memcpy (&(sin.sin_addr.s_addr), hp->h_addr, sizeof (hp->h_addr));
|
||||
sin.sin_port = htons (server_port);
|
||||
|
||||
/* datagram socket */
|
||||
if (connect (s, (struct sockaddr *) &sin, sizeof (sin)) < 0)
|
||||
{
|
||||
close (s);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
static int
|
||||
rtp_connect (char *hostname, int port)
|
||||
{
|
||||
struct sockaddr_in sin;
|
||||
struct timeval tv;
|
||||
int err, err_len;
|
||||
int rxsockbufsz;
|
||||
int s;
|
||||
fd_set set;
|
||||
|
||||
if (port <= 1023)
|
||||
return -1;
|
||||
|
||||
s = socket (PF_INET, SOCK_DGRAM, 0);
|
||||
if (s == -1)
|
||||
return -1;
|
||||
|
||||
sin.sin_family = AF_INET;
|
||||
if (!hostname || !strcmp (hostname, "0.0.0.0"))
|
||||
sin.sin_addr.s_addr = htonl (INADDR_ANY);
|
||||
else
|
||||
#ifndef HAVE_WINSOCK2
|
||||
#ifdef USE_ATON
|
||||
inet_aton (hostname, &sin.sin_addr);
|
||||
#else
|
||||
inet_pton (AF_INET, hostname, &sin.sin_addr);
|
||||
#endif
|
||||
#else
|
||||
sin.sin_addr.s_addr = htonl (INADDR_ANY);
|
||||
#endif
|
||||
sin.sin_port = htons (port);
|
||||
|
||||
/* Increase the socket rx buffer size to maximum -- this is UDP */
|
||||
rxsockbufsz = 240 * 1024;
|
||||
if (setsockopt (s, SOL_SOCKET, SO_RCVBUF,
|
||||
&rxsockbufsz, sizeof (rxsockbufsz)))
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR, "Couldn't set receive socket buffer size\n");
|
||||
|
||||
/* if multicast address, add membership */
|
||||
if ((ntohl (sin.sin_addr.s_addr) >> 28) == 0xe)
|
||||
{
|
||||
struct ip_mreq mcast;
|
||||
mcast.imr_multiaddr.s_addr = sin.sin_addr.s_addr;
|
||||
mcast.imr_interface.s_addr = 0;
|
||||
|
||||
if (setsockopt (s, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mcast, sizeof (mcast)))
|
||||
{
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR, "IP_ADD_MEMBERSHIP failed\n");
|
||||
close (s);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/* datagram socket */
|
||||
if (bind (s, (struct sockaddr *) &sin, sizeof (sin)))
|
||||
{
|
||||
#ifndef HAVE_WINSOCK2
|
||||
if (errno != EINPROGRESS)
|
||||
#else
|
||||
if (WSAGetLastError() != WSAEINPROGRESS)
|
||||
#endif
|
||||
{
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR, "bind: %s\n", strerror (errno));
|
||||
close (s);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
tv.tv_sec = 0;
|
||||
tv.tv_usec = (1 * 1000000); /* 1 second timeout */
|
||||
|
||||
FD_ZERO (&set);
|
||||
FD_SET (s, &set);
|
||||
|
||||
err = select (s + 1, &set, NULL, NULL, &tv);
|
||||
if (err < 0)
|
||||
{
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR, "Select failed: %s\n", strerror (errno));
|
||||
close (s);
|
||||
return -1;
|
||||
}
|
||||
else if (err == 0)
|
||||
{
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR, "Timeout! No data from host %s\n", hostname);
|
||||
close (s);
|
||||
return -1;
|
||||
}
|
||||
|
||||
err_len = sizeof (err);
|
||||
getsockopt (s, SOL_SOCKET, SO_ERROR, &err, (socklen_t *) &err_len);
|
||||
if (err)
|
||||
{
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR, "Socket error: %d\n", err);
|
||||
close (s);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
static int
|
||||
is_multicast_address (char *addr)
|
||||
{
|
||||
struct sockaddr_in sin;
|
||||
|
||||
if (!addr)
|
||||
return -1;
|
||||
|
||||
sin.sin_family = AF_INET;
|
||||
inet_pton (AF_INET, addr, &sin.sin_addr);
|
||||
|
||||
if ((ntohl (sin.sin_addr.s_addr) >> 28) == 0xe)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct rtp_rtsp_session_t *
|
||||
rtp_setup_and_play (rtsp_t *rtsp_session)
|
||||
{
|
||||
struct rtp_rtsp_session_t* rtp_session = NULL;
|
||||
const fsdp_media_description_t *med_dsc = NULL;
|
||||
char temp_buf[MAX_LENGTH + 1];
|
||||
char npt[256];
|
||||
|
||||
char* answer;
|
||||
char* sdp;
|
||||
char *server_addr = NULL;
|
||||
char *destination = NULL;
|
||||
|
||||
int statut;
|
||||
int content_length = 0;
|
||||
int is_multicast = 0;
|
||||
|
||||
fsdp_description_t *dsc = NULL;
|
||||
fsdp_error_t result;
|
||||
|
||||
int client_rtp_port = -1;
|
||||
int client_rtcp_port = -1;
|
||||
int server_rtp_port = -1;
|
||||
int server_rtcp_port = -1;
|
||||
int rtp_sock = -1;
|
||||
int rtcp_sock = -1;
|
||||
|
||||
/* 1. send a RTSP DESCRIBE request to server */
|
||||
rtsp_schedule_field (rtsp_session, RTSP_ACCEPT_SDP);
|
||||
statut = rtsp_request_describe (rtsp_session, NULL);
|
||||
if (statut < 200 || statut > 299)
|
||||
return NULL;
|
||||
|
||||
answer = rtsp_search_answers (rtsp_session, RTSP_CONTENT_LENGTH);
|
||||
if (answer)
|
||||
content_length = atoi (answer);
|
||||
else
|
||||
return NULL;
|
||||
|
||||
answer = rtsp_search_answers (rtsp_session, RTSP_CONTENT_TYPE);
|
||||
if (!answer || !strstr (answer, RTSP_APPLICATION_SDP))
|
||||
return NULL;
|
||||
|
||||
/* 2. read SDP message from server */
|
||||
sdp = (char *) malloc (content_length + 1);
|
||||
if (rtsp_read_data (rtsp_session, sdp, content_length) <= 0)
|
||||
{
|
||||
free (sdp);
|
||||
return NULL;
|
||||
}
|
||||
sdp[content_length] = 0;
|
||||
|
||||
/* 3. parse SDP message */
|
||||
dsc = fsdp_description_new ();
|
||||
result = fsdp_parse (sdp, dsc);
|
||||
if (result != FSDPE_OK)
|
||||
{
|
||||
free (sdp);
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
mp_msg (MSGT_OPEN, MSGL_V, "SDP:\n%s\n", sdp);
|
||||
free (sdp);
|
||||
|
||||
/* 4. check for number of media streams: only one is supported */
|
||||
if (fsdp_get_media_count (dsc) != 1)
|
||||
{
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR,
|
||||
"A single media stream only is supported atm.\n");
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* 5. set the Normal Play Time parameter
|
||||
* use range provided by server in SDP or start now if empty */
|
||||
sprintf (npt, RTSP_RANGE);
|
||||
if (fsdp_get_range (dsc))
|
||||
strcat (npt, fsdp_get_range (dsc));
|
||||
else
|
||||
strcat (npt, RTSP_NPT_NOW);
|
||||
|
||||
/* 5. check for a valid media stream */
|
||||
med_dsc = fsdp_get_media (dsc, 0);
|
||||
if (!med_dsc)
|
||||
{
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* 6. parse the `m=<media> <port> <transport> <fmt list>' line */
|
||||
|
||||
/* check for an A/V media */
|
||||
if (fsdp_get_media_type (med_dsc) != FSDP_MEDIA_VIDEO &&
|
||||
fsdp_get_media_type (med_dsc) != FSDP_MEDIA_AUDIO)
|
||||
{
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* only RTP/AVP transport method is supported right now */
|
||||
if (fsdp_get_media_transport_protocol (med_dsc) != FSDP_TP_RTP_AVP)
|
||||
{
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* only MPEG-TS is supported at the moment */
|
||||
if (!strstr (fsdp_get_media_format (med_dsc, 0),
|
||||
RTSP_MEDIA_CONTAINER_MPEG_TS))
|
||||
{
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* get client port (if any) advised by server */
|
||||
client_rtp_port = fsdp_get_media_port (med_dsc);
|
||||
if (client_rtp_port == -1)
|
||||
{
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* if client_rtp_port = 0 => let client randomly pick one */
|
||||
if (client_rtp_port == 0)
|
||||
{
|
||||
/* TODO: we should check if the port is in use first */
|
||||
if (rtsp_port)
|
||||
client_rtp_port = rtsp_port;
|
||||
else
|
||||
client_rtp_port = RTSP_DEFAULT_PORT;
|
||||
}
|
||||
|
||||
/* RTCP port generally is RTP port + 1 */
|
||||
client_rtcp_port = client_rtp_port + 1;
|
||||
|
||||
mp_msg (MSGT_OPEN, MSGL_V,
|
||||
"RTP Port from SDP appears to be: %d\n", client_rtp_port);
|
||||
mp_msg (MSGT_OPEN, MSGL_V,
|
||||
"RTCP Port from SDP appears to be: %d\n", client_rtcp_port);
|
||||
|
||||
/* 7. parse the `c=<network type> <addr type> <connection address>' line */
|
||||
|
||||
/* check for a valid media network type (inet) */
|
||||
if (fsdp_get_media_network_type (med_dsc) != FSDP_NETWORK_TYPE_INET)
|
||||
{
|
||||
/* no control for media: try global one instead */
|
||||
if (fsdp_get_global_conn_network_type (dsc) != FSDP_NETWORK_TYPE_INET)
|
||||
{
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* only IPv4 is supported atm. */
|
||||
if (fsdp_get_media_address_type (med_dsc) != FSDP_ADDRESS_TYPE_IPV4)
|
||||
{
|
||||
/* no control for media: try global one instead */
|
||||
if (fsdp_get_global_conn_address_type (dsc) != FSDP_ADDRESS_TYPE_IPV4)
|
||||
{
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* get the media server address to connect to */
|
||||
if (fsdp_get_media_address (med_dsc))
|
||||
server_addr = strdup (fsdp_get_media_address (med_dsc));
|
||||
else if (fsdp_get_global_conn_address (dsc))
|
||||
{
|
||||
/* no control for media: try global one instead */
|
||||
server_addr = strdup (fsdp_get_global_conn_address (dsc));
|
||||
}
|
||||
|
||||
if (!server_addr)
|
||||
{
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* check for a UNICAST or MULTICAST address to connect to */
|
||||
is_multicast = is_multicast_address (server_addr);
|
||||
|
||||
/* 8. initiate an RTP session */
|
||||
rtp_session = rtp_session_new ();
|
||||
if (!rtp_session)
|
||||
{
|
||||
free (server_addr);
|
||||
fsdp_description_delete (dsc);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* get the media control URL */
|
||||
if (fsdp_get_media_control (med_dsc, 0))
|
||||
rtp_session->control_url = strdup (fsdp_get_media_control (med_dsc, 0));
|
||||
fsdp_description_delete (dsc);
|
||||
if (!rtp_session->control_url)
|
||||
{
|
||||
free (server_addr);
|
||||
rtp_session_free (rtp_session);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* 9. create the payload for RTSP SETUP request */
|
||||
memset (temp_buf, '\0', MAX_LENGTH);
|
||||
snprintf (temp_buf, MAX_LENGTH,
|
||||
RTSP_TRANSPORT_REQUEST,
|
||||
is_multicast ? RTSP_TRANSPORT_MULTICAST : RTSP_TRANSPORT_UNICAST,
|
||||
is_multicast ? RTSP_MULTICAST_PORT : RTSP_UNICAST_CLIENT_PORT,
|
||||
client_rtp_port, client_rtcp_port);
|
||||
mp_msg (MSGT_OPEN, MSGL_V, "RTSP Transport: %s\n", temp_buf);
|
||||
|
||||
rtsp_unschedule_field (rtsp_session, RTSP_SESSION);
|
||||
rtsp_schedule_field (rtsp_session, temp_buf);
|
||||
|
||||
/* 10. check for the media control URL type and initiate RTSP SETUP */
|
||||
if (!strncmp (rtp_session->control_url, "rtsp://", 7)) /* absolute URL */
|
||||
statut = rtsp_request_setup (rtsp_session,
|
||||
rtp_session->control_url, NULL);
|
||||
else /* relative URL */
|
||||
statut = rtsp_request_setup (rtsp_session,
|
||||
NULL, rtp_session->control_url);
|
||||
|
||||
if (statut < 200 || statut > 299)
|
||||
{
|
||||
free (server_addr);
|
||||
rtp_session_free (rtp_session);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* 11. parse RTSP SETUP response: we need it to actually determine
|
||||
* the real address and port to connect to */
|
||||
answer = rtsp_search_answers (rtsp_session, RTSP_TRANSPORT);
|
||||
if (!answer)
|
||||
{
|
||||
free (server_addr);
|
||||
rtp_session_free (rtp_session);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* check for RTP and RTCP ports to bind according to how request was done */
|
||||
is_multicast = 0;
|
||||
if (strstr (answer, RTSP_TRANSPORT_MULTICAST))
|
||||
is_multicast = 1;
|
||||
|
||||
if (is_multicast)
|
||||
parse_port (answer, RTSP_MULTICAST_PORT,
|
||||
&client_rtp_port, &client_rtcp_port);
|
||||
else
|
||||
{
|
||||
parse_port (answer, RTSP_UNICAST_CLIENT_PORT,
|
||||
&client_rtp_port, &client_rtcp_port);
|
||||
parse_port (answer, RTSP_UNICAST_SERVER_PORT,
|
||||
&server_rtp_port, &server_rtcp_port);
|
||||
}
|
||||
|
||||
/* now check network settings as determined by server */
|
||||
destination = parse_destination (answer);
|
||||
if (!destination)
|
||||
destination = strdup (server_addr);
|
||||
free (server_addr);
|
||||
|
||||
mp_msg (MSGT_OPEN, MSGL_V, "RTSP Destination: %s\n", destination);
|
||||
mp_msg (MSGT_OPEN, MSGL_V, "Client RTP port : %d\n", client_rtp_port);
|
||||
mp_msg (MSGT_OPEN, MSGL_V, "Client RTCP port : %d\n", client_rtcp_port);
|
||||
mp_msg (MSGT_OPEN, MSGL_V, "Server RTP port : %d\n", server_rtp_port);
|
||||
mp_msg (MSGT_OPEN, MSGL_V, "Server RTCP port : %d\n", server_rtcp_port);
|
||||
|
||||
/* 12. performs RTSP PLAY request */
|
||||
rtsp_schedule_field (rtsp_session, npt);
|
||||
statut = rtsp_request_play (rtsp_session, NULL);
|
||||
if (statut < 200 || statut > 299)
|
||||
{
|
||||
rtp_session_free (rtp_session);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* 13. create RTP and RTCP connections */
|
||||
rtp_sock = rtp_connect (destination, client_rtp_port);
|
||||
rtcp_sock = rtcp_connect (client_rtcp_port, server_rtcp_port, destination);
|
||||
rtp_session_set_fd (rtp_session, rtp_sock, rtcp_sock);
|
||||
free (destination);
|
||||
|
||||
mp_msg (MSGT_OPEN, MSGL_V, "RTP Sock : %d\nRTCP Sock : %d\n",
|
||||
rtp_session->rtp_socket, rtp_session->rtcp_socket);
|
||||
|
||||
if (rtp_session->rtp_socket == -1)
|
||||
{
|
||||
rtp_session_free (rtp_session);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return rtp_session;
|
||||
}
|
||||
43
libmpdemux/librtsp/rtsp_rtp.h
Normal file
43
libmpdemux/librtsp/rtsp_rtp.h
Normal file
@ -0,0 +1,43 @@
|
||||
/*
|
||||
* Copyright (C) 2006 Benjamin Zores
|
||||
* heavily base on the Freebox patch for xine by Vincent Mussard
|
||||
* but with many enhancements for better RTSP RFC compliance.
|
||||
*
|
||||
* This program 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 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
#ifndef _HAVE_RTSP_RTP_H_
|
||||
#define _HAVE_RTSP_RTP_H_
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#include "rtsp.h"
|
||||
|
||||
#define MAX_PREVIEW_SIZE 4096
|
||||
|
||||
struct rtp_rtsp_session_t {
|
||||
int rtp_socket;
|
||||
int rtcp_socket;
|
||||
char *control_url;
|
||||
int count;
|
||||
};
|
||||
|
||||
struct rtp_rtsp_session_t *rtp_setup_and_play (rtsp_t* rtsp_session);
|
||||
off_t rtp_read (struct rtp_rtsp_session_t* st, char *buf, off_t length);
|
||||
void rtp_session_free (struct rtp_rtsp_session_t *st);
|
||||
void rtcp_send_rr (rtsp_t *s, struct rtp_rtsp_session_t *st);
|
||||
|
||||
#endif /* _HAVE_RTSP_RTP_H_ */
|
||||
|
||||
@ -23,6 +23,9 @@
|
||||
*
|
||||
*
|
||||
* high level interface to rtsp servers.
|
||||
*
|
||||
* 2006, Benjamin Zores and Vincent Mussard
|
||||
* Support for MPEG-TS streaming through RFC compliant RTSP servers
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
@ -42,7 +45,9 @@
|
||||
#include <inttypes.h>
|
||||
|
||||
#include "mp_msg.h"
|
||||
#include "../rtp.h"
|
||||
#include "rtsp.h"
|
||||
#include "rtsp_rtp.h"
|
||||
#include "rtsp_session.h"
|
||||
#include "../realrtsp/real.h"
|
||||
#include "../realrtsp/rmff.h"
|
||||
@ -53,6 +58,7 @@
|
||||
#define LOG
|
||||
*/
|
||||
|
||||
#define RTSP_OPTIONS_PUBLIC "Public"
|
||||
#define RTSP_OPTIONS_SERVER "Server"
|
||||
#define RTSP_OPTIONS_LOCATION "Location"
|
||||
#define RTSP_OPTIONS_REAL "RealChallenge1"
|
||||
@ -63,6 +69,7 @@
|
||||
struct rtsp_session_s {
|
||||
rtsp_t *s;
|
||||
struct real_rtsp_session_t* real_session;
|
||||
struct rtp_rtsp_session_t* rtp_session;
|
||||
};
|
||||
|
||||
//rtsp_session_t *rtsp_session_start(char *mrl) {
|
||||
@ -76,6 +83,7 @@ rtsp_session_t *rtsp_session_start(int fd, char **mrl, char *path, char *host, i
|
||||
rtsp_session = malloc (sizeof (rtsp_session_t));
|
||||
rtsp_session->s = NULL;
|
||||
rtsp_session->real_session = NULL;
|
||||
rtsp_session->rtp_session = NULL;
|
||||
|
||||
//connect:
|
||||
*redir = 0;
|
||||
@ -141,13 +149,52 @@ rtsp_session_t *rtsp_session_start(int fd, char **mrl, char *path, char *host, i
|
||||
rtsp_session->real_session->recv_size =
|
||||
rtsp_session->real_session->header_len;
|
||||
rtsp_session->real_session->recv_read = 0;
|
||||
} else
|
||||
} else /* not a Real server : try RTP instead */
|
||||
{
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR,"rtsp_session: Not a Real server. Server type is '%s'.\n",server);
|
||||
rtsp_close(rtsp_session->s);
|
||||
free(server);
|
||||
free(rtsp_session);
|
||||
return NULL;
|
||||
char *public = NULL;
|
||||
|
||||
/* look for the Public: field in response to RTSP OPTIONS */
|
||||
public = strdup (rtsp_search_answers (rtsp_session->s,
|
||||
RTSP_OPTIONS_PUBLIC));
|
||||
if (!public)
|
||||
{
|
||||
rtsp_close (rtsp_session->s);
|
||||
free (server);
|
||||
free (mrl_line);
|
||||
free (rtsp_session);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* check for minimalistic RTSP RFC compliance */
|
||||
if (!strstr (public, RTSP_METHOD_DESCRIBE)
|
||||
|| !strstr (public, RTSP_METHOD_SETUP)
|
||||
|| !strstr (public, RTSP_METHOD_PLAY)
|
||||
|| !strstr (public, RTSP_METHOD_TEARDOWN))
|
||||
{
|
||||
free (public);
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR,
|
||||
"Remote server does not meet minimal RTSP 1.0 compliance.\n");
|
||||
rtsp_close (rtsp_session->s);
|
||||
free (server);
|
||||
free (mrl_line);
|
||||
free (rtsp_session);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
free (public);
|
||||
rtsp_session->rtp_session = rtp_setup_and_play (rtsp_session->s);
|
||||
|
||||
/* neither a Real or an RTP server */
|
||||
if (!rtsp_session->rtp_session)
|
||||
{
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR, "rtsp_session: unsupported RTSP server. ");
|
||||
mp_msg (MSGT_OPEN, MSGL_ERR, "Server type is '%s'.\n", server);
|
||||
rtsp_close (rtsp_session->s);
|
||||
free (server);
|
||||
free (mrl_line);
|
||||
free (rtsp_session);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
free(server);
|
||||
|
||||
@ -194,6 +241,19 @@ int rtsp_session_read (rtsp_session_t *this, char *data, int len) {
|
||||
|
||||
return len;
|
||||
}
|
||||
else if (this->rtp_session)
|
||||
{
|
||||
int l = 0;
|
||||
|
||||
l = read_rtp_from_server (this->rtp_session->rtp_socket, data, len);
|
||||
/* send RTSP and RTCP keepalive */
|
||||
rtcp_send_rr (this->s, this->rtp_session);
|
||||
|
||||
if (l == 0)
|
||||
rtsp_session_end (this);
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -203,5 +263,7 @@ void rtsp_session_end(rtsp_session_t *session) {
|
||||
rtsp_close(session->s);
|
||||
if (session->real_session)
|
||||
free_real_rtsp_session (session->real_session);
|
||||
if (session->rtp_session)
|
||||
rtp_session_free (session->rtp_session);
|
||||
free(session);
|
||||
}
|
||||
|
||||
@ -23,6 +23,9 @@
|
||||
*
|
||||
*
|
||||
* high level interface to rtsp servers.
|
||||
*
|
||||
* 2006, Benjamin Zores and Vincent Mussard
|
||||
* Support for MPEG-TS streaming through RFC compliant RTSP servers
|
||||
*/
|
||||
|
||||
#ifndef HAVE_RTSP_SESSION_H
|
||||
|
||||
@ -189,7 +189,7 @@ static int rtp_get_next(int fd, char *buffer, int length)
|
||||
|
||||
|
||||
// Read next rtp packet using cache
|
||||
static int read_rtp_from_server(int fd, char *buffer, int length) {
|
||||
int read_rtp_from_server(int fd, char *buffer, int length) {
|
||||
// Following test is ASSERT (i.e. uneuseful if code is correct)
|
||||
if(buffer==NULL || length<STREAM_BUFFER_SIZE) {
|
||||
mp_msg(MSGT_NETWORK, MSGL_ERR, "RTP buffer invalid; no data return from network\n");
|
||||
|
||||
@ -33,5 +33,6 @@ struct rtpheader { /* in network byte order */
|
||||
|
||||
|
||||
static int getrtp2(int fd, struct rtpheader *rh, char** data, int* lengthData);
|
||||
int read_rtp_from_server(int fd, char *buffer, int length);
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue
Block a user