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");
--- a/libmpdemux/rtp.h	Mon Jun 26 19:04:59 2006 +0000
+++ b/libmpdemux/rtp.h	Mon Jun 26 21:27:57 2006 +0000
@@ -33,5 +33,6 @@
 
 
 static int getrtp2(int fd, struct rtpheader *rh, char** data, int* lengthData);
+int read_rtp_from_server(int fd, char *buffer, int length);
 
 #endif