Mercurial > mplayer.hg
changeset 18829:317e0fd394c5
added new native rtsp demuxer code for mpeg-ts over rtp (now both real and non-real servers should be handled)
| author | ben |
|---|---|
| date | Mon, 26 Jun 2006 21:27:57 +0000 |
| parents | 55ebe20fadbc |
| children | 6ec80634cd91 |
| files | cfg-common.h libmpdemux/Makefile libmpdemux/librtsp/rtsp_rtp.c libmpdemux/librtsp/rtsp_rtp.h libmpdemux/librtsp/rtsp_session.c libmpdemux/librtsp/rtsp_session.h libmpdemux/rtp.c libmpdemux/rtp.h |
| diffstat | 8 files changed, 805 insertions(+), 11 deletions(-) [+] |
line wrap: on
line diff
--- a/cfg-common.h Mon Jun 26 19:04:59 2006 +0000 +++ b/cfg-common.h Mon Jun 26 21:27:57 2006 +0000 @@ -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 @@ #ifdef STREAMING_LIVE555 extern int rtspStreamOverTCP; +#endif extern int rtsp_port; -#endif extern int audio_stream_cache;
--- a/libmpdemux/Makefile Mon Jun 26 19:04:59 2006 +0000 +++ b/libmpdemux/Makefile Mon Jun 26 21:27:57 2006 +0000 @@ -139,6 +139,7 @@ realrtsp/xbuffer.c \ SRCS += librtsp/rtsp.c \ + librtsp/rtsp_rtp.c \ librtsp/rtsp_session.c \ SRCS += freesdp/common.c \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libmpdemux/librtsp/rtsp_rtp.c Mon Jun 26 21:27:57 2006 +0000 @@ -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; +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libmpdemux/librtsp/rtsp_rtp.h Mon Jun 26 21:27:57 2006 +0000 @@ -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_ */ +
--- a/libmpdemux/librtsp/rtsp_session.c Mon Jun 26 19:04:59 2006 +0000 +++ b/libmpdemux/librtsp/rtsp_session.c Mon Jun 26 21:27:57 2006 +0000 @@ -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 = 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->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 @@ 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 @@ 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); }
--- a/libmpdemux/librtsp/rtsp_session.h Mon Jun 26 19:04:59 2006 +0000 +++ b/libmpdemux/librtsp/rtsp_session.h Mon Jun 26 21:27:57 2006 +0000 @@ -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
--- a/libmpdemux/rtp.c Mon Jun 26 19:04:59 2006 +0000 +++ b/libmpdemux/rtp.c Mon Jun 26 21:27:57 2006 +0000 @@ -189,7 +189,7 @@ // 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");