]> git.sesse.net Git - vlc/blobdiff - modules/stream_out/rtp.c
Various RTSP conformance fixes:
[vlc] / modules / stream_out / rtp.c
index 6f08d41f8a8ab851e86ce8f6ddeee34c7e6819ba..0cacb450ab56ab9f16a067f449f6b016778e28cf 100644 (file)
@@ -25,8 +25,6 @@
  * Preamble
  *****************************************************************************/
 #include "config.h"
-#include <stdio.h>
-#include <stdlib.h>
 #ifdef HAVE_UNISTD_H
 #   include <unistd.h>
 #endif
@@ -41,6 +39,7 @@
 #include <vlc_url.h>
 #include <vlc_network.h>
 #include <vlc_charset.h>
+#include <vlc_strings.h>
 
 /*****************************************************************************
  * Module descriptor
@@ -286,8 +285,8 @@ static int  RtspCallbackId( httpd_callback_sys_t *, httpd_client_t *,
                             httpd_message_t *, httpd_message_t * );
 
 
-static rtsp_client_t *RtspClientNew( sout_stream_t *, char *psz_session );
-static rtsp_client_t *RtspClientGet( sout_stream_t *, char *psz_session );
+static rtsp_client_t *RtspClientNew( sout_stream_t *, const char *psz_session );
+static rtsp_client_t *RtspClientGet( sout_stream_t *, const char *psz_session );
 static void           RtspClientDel( sout_stream_t *, rtsp_client_t * );
 
 /*****************************************************************************
@@ -306,14 +305,10 @@ static int Open( vlc_object_t *p_this )
                        ppsz_sout_options, p_stream->p_cfg );
 
     p_sys = malloc( sizeof( sout_stream_sys_t ) );
+    if( p_sys == NULL )
+        return VLC_ENOMEM;
 
-    p_sys->psz_destination = var_GetString( p_stream, SOUT_CFG_PREFIX "dst" );
-    if( *p_sys->psz_destination == '\0' )
-    {
-        free( p_sys->psz_destination );
-        p_sys->psz_destination = NULL;
-    }
-
+    p_sys->psz_destination = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "dst" );
     p_sys->psz_session_name = var_GetString( p_stream, SOUT_CFG_PREFIX "name" );
     p_sys->psz_session_description = var_GetString( p_stream, SOUT_CFG_PREFIX "description" );
     p_sys->psz_session_url = var_GetString( p_stream, SOUT_CFG_PREFIX "url" );
@@ -377,29 +372,20 @@ static int Open( vlc_object_t *p_this )
         return VLC_EGENERIC;
     }
 
-    var_Get( p_stream, SOUT_CFG_PREFIX "ttl", &val );
-    if( val.i_int == 0 )
+    p_sys->i_ttl = var_GetInteger( p_stream, SOUT_CFG_PREFIX "ttl" );
+    if( p_sys->i_ttl == 0 )
     {
         /* Normally, we should let the default hop limit up to the core,
          * but we have to know it to build our SDP properly, which is why
          * we ask the core. FIXME: broken when neither sout-rtp-ttl nor
          * ttl are set. */
-        val.i_int = config_GetInt( p_stream, "ttl" );
+        p_sys->i_ttl = config_GetInt( p_stream, "ttl" );
     }
-    if( val.i_int > 255 ) val.i_int = 255;
+    if( p_sys->i_ttl > 255 )
+        p_sys->i_ttl = 255;
     /* must not exceed 999 once formatted */
 
-    if( val.i_int < 0 )
-    {
-        msg_Err( p_stream, "illegal TTL %d", val.i_int );
-        free( p_sys );
-        return VLC_EGENERIC;
-    }
-    p_sys->i_ttl = val.i_int;
-
-
-    var_Get( p_stream, SOUT_CFG_PREFIX "mp4a-latm", &val );
-    p_sys->b_latm = val.b_bool;
+    p_sys->b_latm = var_GetBool( p_stream, SOUT_CFG_PREFIX "mp4a-latm" );
 
     p_sys->i_payload_type = 96;
     p_sys->i_es = 0;
@@ -436,7 +422,8 @@ static int Open( vlc_object_t *p_this )
     if( *val.psz_string )
     {
         sout_access_out_t *p_grab;
-        char *psz_rtpmap, url[NI_MAXHOST + 8], access[17], psz_ttl[5], ipv;
+        const char *psz_rtpmap;
+        char url[NI_MAXHOST + 8], access[22], psz_ttl[5], ipv;
 
         if( b_rtsp )
         {
@@ -446,13 +433,14 @@ static int Open( vlc_object_t *p_this )
         }
         else if( !p_sys->psz_destination || *p_sys->psz_destination == '\0' )
         {
-            msg_Err( p_stream, "rtp needs a destination when muxing" );
+            msg_Err( p_stream, "RTP needs a destination when muxing" );
             free( p_sys );
             return VLC_EGENERIC;
         }
 
         /* Check muxer type */
-        if( !strncasecmp( val.psz_string, "ps", 2 ) || !strncasecmp( val.psz_string, "mpeg1", 5 ) )
+        if( !strncasecmp( val.psz_string, "ps", 2 )
+         || !strncasecmp( val.psz_string, "mpeg1", 5 ) )
         {
             psz_rtpmap = "MP2P/90000";
         }
@@ -471,26 +459,27 @@ static int Open( vlc_object_t *p_this )
         /* create the access out */
         if( p_sys->i_ttl > 0 )
         {
-            sprintf( access, "udp{raw,ttl=%d}", p_sys->i_ttl );
+            sprintf( access, "udp{raw,rtcp,ttl=%d}", p_sys->i_ttl );
         }
         else
         {
-            sprintf( access, "udp{raw}" );
+            strcat( access, "udp{raw,rtcp}" );
         }
 
-        /* IPv6 needs brackets if not already present */
-        snprintf( url, sizeof( url ),
-                  ( ( p_sys->psz_destination[0] != '[' ) 
-                 && ( strchr( p_sys->psz_destination, ':' ) != NULL ) )
-                  ? "[%s]:%d" : "%s:%d", p_sys->psz_destination,
-                  p_sys->i_port );
-        url[sizeof( url ) - 1] = '\0';
         /* FIXME: we should check that url is a numerical address, otherwise
          * the SDP will be quite broken (regardless of the IP protocol version)
          * Also it might be IPv6 with no ':' if it is a DNS name.
          */
         ipv = ( strchr( p_sys->psz_destination, ':' ) != NULL ) ? '6' : '4';
 
+        /* IPv6 needs brackets if not already present */
+        if ((ipv == '6') && (p_sys->psz_destination[0] != '['))
+            snprintf (url, sizeof (url), "[%s]:%d",p_sys->psz_destination,
+                      p_sys->i_port);
+        else
+            snprintf (url, sizeof (url), "%s:%d",p_sys->psz_destination,
+                      p_sys->i_port);
+
         if( !( p_sys->p_access = sout_AccessOutNew( p_sout, access, url ) ) )
         {
             msg_Err( p_stream, "cannot create the access out for %s://%s",
@@ -513,7 +502,7 @@ static int Open( vlc_object_t *p_this )
         p_grab->p_sout      = p_sout;
         p_grab->psz_access  = strdup( "grab" );
         p_grab->p_cfg       = NULL;
-        p_grab->psz_name    = strdup( "" );
+        p_grab->psz_path    = strdup( "" );
         p_grab->p_sys       = (sout_access_out_sys_t*)p_stream;
         p_grab->pf_seek     = NULL;
         p_grab->pf_write    = AccessOutGrabberWrite;
@@ -536,7 +525,8 @@ static int Open( vlc_object_t *p_this )
           a= source-filter: we need our source address
            a= x-plgroup: (missing)
            RTP packets need to get the correct src IP address  */
-        if( net_AddressIsMulticast( (vlc_object_t *)p_stream, p_sys->psz_destination ) )
+        if( ipv == '4'
+         && net_AddressIsMulticast( VLC_OBJECT(p_stream), p_sys->psz_destination ) )
         {
             snprintf( psz_ttl, sizeof( psz_ttl ), "/%d", p_sys->i_ttl );
             psz_ttl[sizeof( psz_ttl ) - 1] = '\0';
@@ -604,7 +594,8 @@ static int Open( vlc_object_t *p_this )
                 if( p_cfg->psz_value == NULL || *p_cfg->psz_value == '\0' )
                     continue;
 
-                if( !strcmp( p_cfg->psz_value, val.psz_string ) )   /* needed both :sout-rtp-sdp= and rtp{sdp=} can be used */
+                /* needed both :sout-rtp-sdp= and rtp{sdp=} can be used */
+                if( !strcmp( p_cfg->psz_value, val.psz_string ) ) 
                     continue;
 
                 SDPHandleUrl( p_stream, p_cfg->psz_value );
@@ -640,60 +631,44 @@ static void Close( vlc_object_t * p_this )
             block_Release( p_sys->packet );
         }
         if( p_sys->b_export_sap )
-        {   
+        {
             p_sys->p_mux = NULL;
             SapSetup( p_stream );
         }
     }
 
     while( p_sys->i_rtsp > 0 )
-    {
         RtspClientDel( p_stream, p_sys->rtsp[0] );
-    }
 
     vlc_mutex_destroy( &p_sys->lock_sdp );
 
     if( p_sys->p_httpd_file )
-    {
         httpd_FileDelete( p_sys->p_httpd_file );
-    }
+
     if( p_sys->p_httpd_host )
-    {
         httpd_HostDelete( p_sys->p_httpd_host );
-    }
+
     if( p_sys->p_rtsp_url )
-    {
         httpd_UrlDelete( p_sys->p_rtsp_url );
-    }
+
     if( p_sys->p_rtsp_host )
-    {
         httpd_HostDelete( p_sys->p_rtsp_host );
-    }
+
     if( p_sys->psz_session_name )
-    {
         free( p_sys->psz_session_name );
-        p_sys->psz_session_name = NULL;
-    }
+
     if( p_sys->psz_session_description )
-    {
         free( p_sys->psz_session_description );
-        p_sys->psz_session_description = NULL;
-    }
+
     if( p_sys->psz_session_url )
-    {
         free( p_sys->psz_session_url );
-        p_sys->psz_session_url = NULL;
-    }
+
     if( p_sys->psz_session_email )
-    {
         free( p_sys->psz_session_email );
-        p_sys->psz_session_email = NULL;
-    }
+
     if( p_sys->psz_sdp )
-    {
         free( p_sys->psz_sdp );
-        p_sys->psz_sdp = NULL;
-    }
+
     if( p_sys->b_export_sdp_file )
     {
 #ifdef HAVE_UNISTD_H
@@ -701,6 +676,8 @@ static void Close( vlc_object_t * p_this )
 #endif
         free( p_sys->psz_sdp_file );
     }
+    if( p_sys->psz_destination )
+        free( p_sys->psz_destination );
     free( p_sys );
 }
 
@@ -802,6 +779,7 @@ static char *SDPGenerate( const sout_stream_t *p_stream,
              sizeof( "u=*\r\n" ) + strlen( p_sys->psz_session_url ) +
              sizeof( "e=*\r\n" ) + strlen( p_sys->psz_session_email ) +
              sizeof( "t=0 0\r\n" ) + /* permanent stream */ /* when scheduled from vlm, we should set this info correctly */
+             sizeof( "b=RR:0\r\n" ) +
              sizeof( "a=tool:"PACKAGE_STRING"\r\n" ) +
              sizeof( "c=IN IP4 */*\r\n" ) + 20 + 10 +
              strlen( psz_destination ) ;
@@ -810,6 +788,10 @@ static char *SDPGenerate( const sout_stream_t *p_stream,
         sout_stream_id_t *id = p_sys->es[i];
 
         i_size += strlen( "m=**d*o * RTP/AVP *\r\n" ) + 10 + 10;
+        if ( id->i_bitrate )
+        {
+            i_size += strlen( "b=AS: *\r\n") + 10;
+        }
         if( id->psz_rtpmap )
         {
             i_size += strlen( "a=rtpmap:* *\r\n" ) + strlen( id->psz_rtpmap )+10;
@@ -818,10 +800,6 @@ static char *SDPGenerate( const sout_stream_t *p_stream,
         {
             i_size += strlen( "a=fmtp:* *\r\n" ) + strlen( id->psz_fmtp ) + 10;
         }
-        if ( id->i_bitrate)
-        {
-            i_size += strlen( "b=AS: *\r\n") + 10;
-        }
         if( b_rtsp )
         {
             i_size += strlen( "a=control:*/trackID=*\r\n" ) + strlen( p_sys->psz_rtsp_control ) + 10;
@@ -838,7 +816,7 @@ static char *SDPGenerate( const sout_stream_t *p_stream,
     p += sprintf( p, "v=0\r\n" );
     p += sprintf( p, "o=- "I64Fd" %d IN IP%c %s\r\n",
                   p_sys->i_sdp_id, p_sys->i_sdp_version,
-                  ipv, ipv == '6' ? "::" : "127.0.0.1" );
+                  ipv, ipv == '6' ? "::1" : "127.0.0.1" );
     if( *p_sys->psz_session_name )
         p += sprintf( p, "s=%s\r\n", p_sys->psz_session_name );
     if( *p_sys->psz_session_description )
@@ -853,16 +831,14 @@ static char *SDPGenerate( const sout_stream_t *p_stream,
 
     p += sprintf( p, "c=IN IP%c %s", ipv, psz_destination );
 
-    if( net_AddressIsMulticast( (vlc_object_t *)p_stream, psz_destination ) )
+    if( ( ipv == 4 )
+     && net_AddressIsMulticast( (vlc_object_t *)p_stream, psz_destination ) )
     {
-        /* Add the ttl if it is a multicast address */
-        /* FIXME: 1 is not a correct default value in the case of IPv6 */
-        p += sprintf( p, "/%d\r\n", p_sys->i_ttl ?: 1 );
-    }
-    else
-    {
-        p += sprintf( p, "\r\n" );
+        /* Add the deprecated TTL field if it is an IPv4 multicast address */
+        p += sprintf( p, "/%d", p_sys->i_ttl ?: 1 );
     }
+    p += sprintf( p, "\r\n" );
+    p += sprintf( p, "b=RR:0\r\n" );
 
     for( i = 0; i < p_sys->i_es; i++ )
     {
@@ -882,6 +858,10 @@ static char *SDPGenerate( const sout_stream_t *p_stream,
         {
             continue;
         }
+        if ( id->i_bitrate )
+        {
+            p += sprintf(p,"b=AS:%d\r\n",id->i_bitrate);
+        }
         if( id->psz_rtpmap )
         {
             p += sprintf( p, "a=rtpmap:%d %s\r\n", id->i_payload_type,
@@ -892,13 +872,9 @@ static char *SDPGenerate( const sout_stream_t *p_stream,
             p += sprintf( p, "a=fmtp:%d %s\r\n", id->i_payload_type,
                           id->psz_fmtp );
         }
-        if ( id->i_bitrate)
-        {
-            p += sprintf(p,"b=AS:%d\r\n",id->i_bitrate);
-        }
         if( b_rtsp )
         {
-            p += sprintf( p, "a=control:trackID=%d\r\n", i );
+            p += sprintf( p, "a=control:/trackID=%d\r\n", i );
         }
     }
     if( p_sys->p_mux )
@@ -938,68 +914,6 @@ static void sprintf_hexa( char *s, uint8_t *p_data, int i_data )
     s[2*i_data] = '\0';
 }
 
-static const char basis_64[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-int ap_base64encode_len(int len)
-{
-    return ((len + 2) / 3 * 4) + 1;
-}
-
-int ap_base64encode_binary(char *encoded,
-                                       const unsigned char *string, int len)
-{
-    int i;
-    char *p;
-
-    p = encoded;
-    for (i = 0; i < len - 2; i += 3) {
-        *p++ = basis_64[(string[i] >> 2) & 0x3F];
-        *p++ = basis_64[((string[i] & 0x3) << 4) |
-                        ((int) (string[i + 1] & 0xF0) >> 4)];
-        *p++ = basis_64[((string[i + 1] & 0xF) << 2) |
-                        ((int) (string[i + 2] & 0xC0) >> 6)];
-        *p++ = basis_64[string[i + 2] & 0x3F];
-    }
-    if (i < len) {
-        *p++ = basis_64[(string[i] >> 2) & 0x3F];
-        if (i == (len - 1)) {
-            *p++ = basis_64[((string[i] & 0x3) << 4)];
-            *p++ = '=';
-        }
-        else {
-            *p++ = basis_64[((string[i] & 0x3) << 4) |
-                            ((int) (string[i + 1] & 0xF0) >> 4)];
-            *p++ = basis_64[((string[i + 1] & 0xF) << 2)];
-        }
-        *p++ = '=';
-    }
-
-    *p++ = '\0';
-    return p - encoded;
-}
-
-int ap_base64encode(char *encoded, const char *string, int len)
-{
-    return ap_base64encode_binary(encoded, (const unsigned char *) string, len);
-}
-
-char *b64_encode(char *buf, int len)
-{
-    int elen;
-    char *out;
-
-    if(len == 0)
-        len = strlen(buf);
-
-    elen = ap_base64encode_len(len);
-    out = (char *) malloc(sizeof(char) * (elen + 1));
-
-    ap_base64encode(out, buf, len);
-
-    return out;
-}
-
 static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
 {
     sout_instance_t   *p_sout = p_stream->p_sout;
@@ -1054,18 +968,18 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
 
     if( p_sys->psz_destination )
     {
-        char access[17];
+        char access[22];
         char url[NI_MAXHOST + 8];
 
         /* first try to create the access out */
         if( p_sys->i_ttl )
         {
-            snprintf( access, sizeof( access ), "udp{raw,ttl=%d}",
+            snprintf( access, sizeof( access ), "udp{raw,rtcp,ttl=%d}",
                       p_sys->i_ttl );
             access[sizeof( access ) - 1] = '\0';
         }
         else
-            strcpy( access, "udp{raw}" );
+            strcpy( access, "udp{raw,rtcp}" );
 
         snprintf( url, sizeof( url ), (( p_sys->psz_destination[0] != '[' ) &&
                  strchr( p_sys->psz_destination, ':' )) ? "[%s]:%d" : "%s:%d",
@@ -1155,62 +1069,58 @@ static sout_stream_id_t *Add( sout_stream_t *p_stream, es_format_t *p_fmt )
             id->i_clock_rate = 90000;
             id->psz_rtpmap = strdup( "H264/90000" );
             id->pf_packetize = rtp_packetize_h264;
+            id->psz_fmtp = NULL;
+
             if( p_fmt->i_extra > 0 )
             {
                 uint8_t *p_buffer = p_fmt->p_extra;
                 int     i_buffer = p_fmt->i_extra;
                 char    *p_64_sps = NULL;
                 char    *p_64_pps = NULL;
-                char    hexa[6];
-                
+                char    hexa[6+1];
+
                 while( i_buffer > 4 && 
-                    p_buffer[0] == 0 && p_buffer[1] == 0 &&
-                    p_buffer[2] == 0 && p_buffer[3] == 1 )
+                       p_buffer[0] == 0 && p_buffer[1] == 0 &&
+                       p_buffer[2] == 0 && p_buffer[3] == 1 )
                 {
                     const int i_nal_type = p_buffer[4]&0x1f;
-                    int i_offset    = 1;
+                    int i_offset;
                     int i_size      = 0;
-                    int i_startcode = 0;
-                    int i_encoded   = 0;
-                    
+
                     msg_Dbg( p_stream, "we found a startcode for NAL with TYPE:%d", i_nal_type );
-                    
-                    for( i_offset = 1; i_offset+3 < i_buffer ; i_offset++)
+
+                    i_size = i_buffer;
+                    for( i_offset = 4; i_offset+3 < i_buffer ; i_offset++)
                     {
-                        if( p_buffer[i_offset] == 0 && p_buffer[i_offset+1] == 0 && p_buffer[i_offset+2] == 0 && p_buffer[i_offset+3] == 1 )
+                        if( !memcmp (p_buffer + i_offset, "\x00\x00\x00\x01", 4 ) )
                         {
                             /* we found another startcode */
-                            i_startcode = i_offset;
+                            i_size = i_offset;
                             break;
-                        } 
+                        }
                     }
-                    i_size = i_startcode ? i_startcode : i_buffer;
                     if( i_nal_type == 7 )
                     {
-                        p_64_sps = (char *)malloc( ap_base64encode_len( i_size - 4) );
-                        i_encoded = ap_base64encode_binary( p_64_sps, &p_buffer[4], i_size - 4 );
-                        p_64_sps[i_encoded] = '\0';
+                        p_64_sps = vlc_b64_encode_binary( &p_buffer[4], i_size - 4 );
                         sprintf_hexa( hexa, &p_buffer[5], 3 );
-                        hexa[6] = '\0'; 
                     }
-                    if( i_nal_type == 8 )
+                    else if( i_nal_type == 8 )
                     {
-                        p_64_pps = (char *)malloc( ap_base64encode_len( i_size - 4) );
-                        i_encoded = ap_base64encode_binary( p_64_pps, &p_buffer[4], i_size - 4 );
-                        p_64_pps[i_encoded] = '\0';
+                        p_64_pps = vlc_b64_encode_binary( &p_buffer[4], i_size - 4 );
                     }
                     i_buffer -= i_size;
                     p_buffer += i_size;
                 }
-                /* FIXME: All this is a bit unsafe */
-                asprintf( &id->psz_fmtp, "packetization-mode=1;profile-level-id=%s;sprop-parameter-sets=%s,%s;", hexa, p_64_sps, p_64_pps );
-                free( p_64_sps );
-                free( p_64_pps );
+                /* */
+                if( p_64_sps && p_64_pps )
+                    asprintf( &id->psz_fmtp, "packetization-mode=1;profile-level-id=%s;sprop-parameter-sets=%s,%s;", hexa, p_64_sps, p_64_pps );
+                if( p_64_sps )
+                    free( p_64_sps );
+                if( p_64_pps )
+                    free( p_64_pps );
             }
-            else
+            if( !id->psz_fmtp )
                 id->psz_fmtp = strdup( "packetization-mode=1" );
-if( p_fmt->i_extra > 0 )
-msg_Dbg( p_stream, "WE HAVE %d bytes extra data", p_fmt->i_extra );
             break;
 
         case VLC_FOURCC( 'm', 'p', '4', 'v' ):
@@ -1334,9 +1244,11 @@ msg_Dbg( p_stream, "WE HAVE %d bytes extra data", p_fmt->i_extra );
 
         if( id->p_rtsp_url )
         {
+            httpd_UrlCatch( id->p_rtsp_url, HTTPD_MSG_DESCRIBE, RtspCallbackId, (void*)id );
             httpd_UrlCatch( id->p_rtsp_url, HTTPD_MSG_SETUP,    RtspCallbackId, (void*)id );
-            //httpd_UrlCatch( id->p_rtsp_url, HTTPD_MSG_PLAY,     RtspCallback, (void*)p_stream );
-            //httpd_UrlCatch( id->p_rtsp_url, HTTPD_MSG_PAUSE,    RtspCallback, (void*)p_stream );
+            httpd_UrlCatch( id->p_rtsp_url, HTTPD_MSG_PLAY,     RtspCallbackId, (void*)id );
+            httpd_UrlCatch( id->p_rtsp_url, HTTPD_MSG_PAUSE,    RtspCallbackId, (void*)id );
+            httpd_UrlCatch( id->p_rtsp_url, HTTPD_MSG_TEARDOWN, RtspCallbackId, (void*)id );
         }
     }
 
@@ -1533,7 +1445,7 @@ static int SapSetup( sout_stream_t *p_stream )
 {
     sout_stream_sys_t *p_sys = p_stream->p_sys;
     sout_instance_t   *p_sout = p_stream->p_sout;
-    announce_method_t *p_method = sout_AnnounceMethodCreate( METHOD_TYPE_SAP );
+    announce_method_t *p_method = sout_SAPMethod();
 
     /* Remove the previous session */
     if( p_sys->p_session != NULL)
@@ -1545,12 +1457,13 @@ static int SapSetup( sout_stream_t *p_stream )
 
     if( ( p_sys->i_es > 0 || p_sys->p_mux ) && p_sys->psz_sdp && *p_sys->psz_sdp )
     {
-        p_sys->p_session = sout_AnnounceRegisterSDP( p_sout, p_sys->psz_sdp,
+        p_sys->p_session = sout_AnnounceRegisterSDP( p_sout, SOUT_CFG_PREFIX,
+                                                     p_sys->psz_sdp,
                                                      p_sys->psz_destination,
                                                      p_method );
     }
 
-    free( p_method );
+    sout_MethodRelease( p_method );
     return VLC_SUCCESS;
 }
 
@@ -1628,11 +1541,11 @@ static int  HttpCallback( httpd_file_sys_t *p_args,
 /****************************************************************************
  * RTSP:
  ****************************************************************************/
-static rtsp_client_t *RtspClientNew( sout_stream_t *p_stream, char *psz_session )
+static rtsp_client_t *RtspClientNew( sout_stream_t *p_stream, const char *psz_session )
 {
     rtsp_client_t *rtsp = malloc( sizeof( rtsp_client_t ));
 
-    rtsp->psz_session = psz_session;
+    rtsp->psz_session = strdup( psz_session );
     rtsp->i_last = 0;
     rtsp->b_playing = VLC_FALSE;
     rtsp->i_id = 0;
@@ -1644,7 +1557,7 @@ static rtsp_client_t *RtspClientNew( sout_stream_t *p_stream, char *psz_session
 
     return rtsp;
 }
-static rtsp_client_t *RtspClientGet( sout_stream_t *p_stream, char *psz_session )
+static rtsp_client_t *RtspClientGet( sout_stream_t *p_stream, const char *psz_session )
 {
     int i;
 
@@ -1699,6 +1612,7 @@ static int RtspSetup( sout_stream_t *p_stream, vlc_url_t *url )
         return VLC_EGENERIC;
     }
     httpd_UrlCatch( p_sys->p_rtsp_url, HTTPD_MSG_DESCRIBE, RtspCallback, (void*)p_stream );
+    httpd_UrlCatch( p_sys->p_rtsp_url, HTTPD_MSG_SETUP,    RtspCallback, (void*)p_stream );
     httpd_UrlCatch( p_sys->p_rtsp_url, HTTPD_MSG_PLAY,     RtspCallback, (void*)p_stream );
     httpd_UrlCatch( p_sys->p_rtsp_url, HTTPD_MSG_PAUSE,    RtspCallback, (void*)p_stream );
     httpd_UrlCatch( p_sys->p_rtsp_url, HTTPD_MSG_TEARDOWN, RtspCallback, (void*)p_stream );
@@ -1713,9 +1627,8 @@ static int  RtspCallback( httpd_callback_sys_t *p_args,
     sout_stream_t *p_stream = (sout_stream_t*)p_args;
     sout_stream_sys_t *p_sys = p_stream->p_sys;
     char *psz_destination = p_sys->psz_destination;
-    char *psz_session = NULL;
-    char *psz_cseq = NULL;
-    int i_cseq = 0;
+    const char *psz_session = NULL;
+    const char *psz_cseq = NULL;
 
     if( answer == NULL || query == NULL )
     {
@@ -1726,7 +1639,12 @@ static int  RtspCallback( httpd_callback_sys_t *p_args,
     answer->i_proto = HTTPD_PROTO_RTSP;
     answer->i_version= query->i_version;
     answer->i_type   = HTTPD_MSG_ANSWER;
+    answer->i_body = 0;
+    answer->p_body = NULL;
 
+    if( httpd_MsgGet( query, "Require" ) != NULL )
+        answer->i_status = 551;
+    else
     switch( query->i_type )
     {
         case HTTPD_MSG_DESCRIBE:
@@ -1734,22 +1652,22 @@ static int  RtspCallback( httpd_callback_sys_t *p_args,
             char *psz_sdp = SDPGenerate( p_stream, psz_destination ? psz_destination : "0.0.0.0", VLC_TRUE );
 
             answer->i_status = 200;
-            answer->psz_status = strdup( "OK" );
-            httpd_MsgAdd( answer, "Content-type",  "%s", "application/sdp" );
-           httpd_MsgAdd( answer, "Content-Base",  "%s/", p_sys->psz_rtsp_control );
+            httpd_MsgAdd( answer, "Content-Type",  "%s", "application/sdp" );
+            httpd_MsgAdd( answer, "Content-Base",  "%s", p_sys->psz_rtsp_control );
             answer->p_body = (uint8_t *)psz_sdp;
             answer->i_body = strlen( psz_sdp );
             break;
         }
 
+        case HTTPD_MSG_SETUP:
+            answer->i_status = 459;
+            break;
+
         case HTTPD_MSG_PLAY:
         {
             rtsp_client_t *rtsp;
             /* for now only multicast so easy */
             answer->i_status = 200;
-            answer->psz_status = strdup( "OK" );
-            answer->i_body = 0;
-            answer->p_body = NULL;
 
             psz_session = httpd_MsgGet( query, "Session" );
             rtsp = RtspClientGet( p_stream, psz_session );
@@ -1780,18 +1698,18 @@ static int  RtspCallback( httpd_callback_sys_t *p_args,
             }
             break;
         }
+
         case HTTPD_MSG_PAUSE:
-            /* FIXME */
-            return VLC_EGENERIC;
+            answer->i_status = 405;
+            httpd_MsgAdd( answer, "Allow", "DESCRIBE, PLAY, TEARDOWN" );
+            break;
+
         case HTTPD_MSG_TEARDOWN:
         {
             rtsp_client_t *rtsp;
 
             /* for now only multicast so easy again */
             answer->i_status = 200;
-            answer->psz_status = strdup( "OK" );
-            answer->i_body = 0;
-            answer->p_body = NULL;
 
             psz_session = httpd_MsgGet( query, "Session" );
             rtsp = RtspClientGet( p_stream, psz_session );
@@ -1826,172 +1744,263 @@ static int  RtspCallback( httpd_callback_sys_t *p_args,
         default:
             return VLC_EGENERIC;
     }
+
     httpd_MsgAdd( answer, "Server", PACKAGE_STRING );
     httpd_MsgAdd( answer, "Content-Length", "%d", answer->i_body );
     psz_cseq = httpd_MsgGet( query, "Cseq" );
-    if( psz_cseq )
-        i_cseq = atoi( psz_cseq );
-    else
-        i_cseq = 0;
-    httpd_MsgAdd( answer, "Cseq", "%d", i_cseq );
+    httpd_MsgAdd( answer, "Cseq", "%s", psz_cseq ? psz_cseq : "0" );
     httpd_MsgAdd( answer, "Cache-Control", "%s", "no-cache" );
 
     if( psz_session )
-    {
         httpd_MsgAdd( answer, "Session", "%s;timeout=5", psz_session );
-    }
     return VLC_SUCCESS;
 }
 
+
+/** Finds the next transport choice */
+static inline const char *transport_next( const char *str )
+{
+    /* Looks for comma */
+    str = strchr( str, ',' );
+    if( str == NULL )
+        return NULL; /* No more transport options */
+
+    str++; /* skips comma */
+    while( strchr( "\r\n\t ", *str ) )
+        str++;
+
+    return (*str) ? str : NULL;
+}
+
+
+/** Finds the next transport parameter */
+static inline const char *parameter_next( const char *str )
+{
+    while( strchr( ",;", *str ) == NULL )
+        str++;
+
+    return (*str == ';') ? (str + 1) : NULL;
+}
+
+
 static int RtspCallbackId( httpd_callback_sys_t *p_args,
-                          httpd_client_t *cl,
-                          httpd_message_t *answer, httpd_message_t *query )
+                           httpd_client_t *cl,
+                           httpd_message_t *answer, httpd_message_t *query )
 {
     sout_stream_id_t *id = (sout_stream_id_t*)p_args;
     sout_stream_t    *p_stream = id->p_stream;
     sout_stream_sys_t *p_sys = p_stream->p_sys;
-    char *psz_session = NULL;
-    char *psz_cseq = NULL;
-    int  i_cseq = 0;
-
+    char psz_session_init[21];
+    const char *psz_session;
+    const char *psz_cseq;
 
     if( answer == NULL || query == NULL )
-    {
         return VLC_SUCCESS;
-    }
     //fprintf( stderr, "RtspCallback query: type=%d\n", query->i_type );
 
+    /* */
     answer->i_proto = HTTPD_PROTO_RTSP;
     answer->i_version= query->i_version;
     answer->i_type   = HTTPD_MSG_ANSWER;
+    answer->i_body = 0;
+    answer->p_body = NULL;
 
+    /* Create new session ID if needed */
+    psz_session = httpd_MsgGet( query, "Session" );
+    if( psz_session == NULL )
+    {
+        /* FIXME: should be somewhat secure randomness */
+        snprintf( psz_session_init, sizeof(psz_session_init), I64Fd,
+                  NTPtime64() + rand() );
+    }
+
+    if( httpd_MsgGet( query, "Require" ) != NULL )
+        answer->i_status = 551;
+    else
     switch( query->i_type )
     {
         case HTTPD_MSG_SETUP:
         {
-            char *psz_transport = httpd_MsgGet( query, "Transport" );
-
-            //fprintf( stderr, "HTTPD_MSG_SETUP: transport=%s\n", psz_transport );
+            answer->i_status = 461;
 
-            if( strstr( psz_transport, "multicast" ) && id->psz_destination )
+            for( const char *tpt = httpd_MsgGet( query, "Transport" );
+                 tpt != NULL;
+                 tpt = transport_next( tpt ) )
             {
-                //fprintf( stderr, "HTTPD_MSG_SETUP: multicast\n" );
-                answer->i_status = 200;
-                answer->psz_status = strdup( "OK" );
-                answer->i_body = 0;
-                answer->p_body = NULL;
-                psz_session = httpd_MsgGet( query, "Session" );
-                if( !psz_session )
-                {
-                    psz_session = malloc( 100 );
-                    sprintf( psz_session, "%d", rand() );
-                }
-                httpd_MsgAdd( answer, "Transport",
-                              "RTP/AVP/UDP;destination=%s;port=%d-%d;ttl=%d",
-                              id->psz_destination, id->i_port,id->i_port+1,
-                              p_sys->i_ttl );
-            }
-            else if( strstr( psz_transport, "unicast" ) && strstr( psz_transport, "client_port=" ) )
-            {
-                int  i_port = atoi( strstr( psz_transport, "client_port=" ) + strlen("client_port=") );
-                char ip[NI_MAXNUMERICHOST], psz_access[17], psz_url[NI_MAXNUMERICHOST + 8];
+                vlc_bool_t b_multicast = VLC_TRUE, b_unsupp = VLC_FALSE;
+                unsigned loport = 5004, hiport = 5005; /* from RFC3551 */
 
-                sout_access_out_t *p_access;
-
-                rtsp_client_t *rtsp = NULL;
+                /* Check transport protocol. */
+                /* Currently, we only support RTP/AVP over UDP */
+                if( strncmp( tpt, "RTP/AVP", 7 ) )
+                    continue;
+                tpt += 7;
+                if( strncmp( tpt, "/UDP", 4 ) == 0 )
+                    tpt += 4;
+                if( strchr( ";,", *tpt ) == NULL )
+                    continue;
 
-                if( httpd_ClientIP( cl, ip ) == NULL )
+                /* Parse transport options */
+                for( const char *opt = parameter_next( tpt );
+                     opt != NULL;
+                     opt = parameter_next( opt ) )
                 {
-                    answer->i_status = 500;
-                    answer->psz_status = strdup( "Internal server error" );
-                    answer->i_body = 0;
-                    answer->p_body = NULL;
-                    break;
+                    if( strncmp( opt, "multicast", 9 ) == 0)
+                        b_multicast = VLC_TRUE;
+                    else
+                    if( strncmp( opt, "unicast", 7 ) == 0 )
+                        b_multicast = VLC_FALSE;
+                    else
+                    if( sscanf( opt, "client_port=%u-%u", &loport, &hiport ) == 2 )
+                        ;
+                    else
+                    if( strncmp( opt, "mode=", 5 ) == 0 )
+                    {
+                        if( strncasecmp( opt + 5, "\"PLAY\"", 6 ) )
+                        {
+                            /* Not playing?! */
+                            b_unsupp = VLC_TRUE;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                    /*
+                     * Every other option is unsupported:
+                     *
+                     * "source" and "append" are invalid.
+                     *
+                     * For multicast, "port", "layers", "ttl" are set by the
+                     * stream output configuration.
+                     *
+                     * For unicast, we do not allow "destination" as it
+                     * carries a DoS risk, and we decide on "server_port".
+                     *
+                     * "interleaved" and "ssrc" are not implemented.
+                     */
+                        b_unsupp = VLC_TRUE;
+                        break;
+                    }
                 }
 
-                //fprintf( stderr, "HTTPD_MSG_SETUP: unicast ip=%s port=%d\n", ip, i_port );
+                if( b_unsupp )
+                    continue;
 
-                psz_session = httpd_MsgGet( query, "Session" );
-                if( !psz_session )
+                if( b_multicast )
                 {
-                    psz_session = malloc( 100 );
-                    sprintf( psz_session, "%d", rand() );
+                    if( id->psz_destination == NULL )
+                        continue;
+
+                    answer->i_status = 200;
 
-                    rtsp = RtspClientNew( p_stream, psz_session );
+                    httpd_MsgAdd( answer, "Transport",
+                                  "RTP/AVP/UDP;destination=%s;port=%d-%d;ttl=%d",
+                                  id->psz_destination, id->i_port, id->i_port+1,
+                                  ( p_sys->i_ttl > 0 ) ? p_sys->i_ttl : 1 );
                 }
                 else
                 {
-                    rtsp = RtspClientGet( p_stream, psz_session );
-                    if( rtsp == NULL )
+                    char ip[NI_MAXNUMERICHOST], psz_access[22],
+                         url[NI_MAXNUMERICHOST + 8];
+                    sout_access_out_t *p_access;
+                    rtsp_client_t *rtsp = NULL;
+
+                    if( ( hiport - loport ) > 1 )
+                        continue;
+
+                    if( psz_session == NULL )
                     {
-                        answer->i_status = 454;
-                        answer->psz_status = strdup( "Unknown session id" );
-                        answer->i_body = 0;
-                        answer->p_body = NULL;
-                        break;
+                        psz_session = psz_session_init;
+                        rtsp = RtspClientNew( p_stream, psz_session );
+                    }
+                    else
+                    {
+                        /* FIXME: we probably need to remove an access out,
+                         * if there is already one for the same ID */
+                        rtsp = RtspClientGet( p_stream, psz_session );
+                        if( rtsp == NULL )
+                        {
+                            answer->i_status = 454;
+                            continue;
+                        }
                     }
-                }
 
-                /* first try to create the access out */
-                if( p_sys->i_ttl )
-                    snprintf( psz_access, sizeof( psz_access ),
-                              "udp{raw,ttl=%d}", p_sys->i_ttl );
-                else
-                    strlcpy( psz_access, "udp{raw}", sizeof( psz_access ) );
+                    if( httpd_ClientIP( cl, ip ) == NULL )
+                    {
+                        answer->i_status = 500;
+                        continue;
+                    }
 
-                snprintf( psz_url, sizeof( psz_url ),
-                         ( strchr( ip, ':' ) != NULL ) ? "[%s]:%d" : "%s:%d",
-                         ip, i_port );
+                    if( p_sys->i_ttl )
+                        snprintf( psz_access, sizeof( psz_access ),
+                                  "udp{raw,rtcp,ttl=%d}", p_sys->i_ttl );
+                    else
+                        strcpy( psz_access, "udp{raw,rtcp}" );
 
-                if( ( p_access = sout_AccessOutNew( p_stream->p_sout, psz_access, psz_url ) ) == NULL )
-                {
-                    msg_Err( p_stream, "cannot create the access out for %s://%s",
-                             psz_access, psz_url );
-                    answer->i_status = 500;
-                    answer->psz_status = strdup( "Internal server error" );
-                    answer->i_body = 0;
-                    answer->p_body = NULL;
-                    break;
-                }
+                    snprintf( url, sizeof( url ),
+                              ( strchr( ip, ':' ) != NULL ) ? "[%s]:%d" : "%s:%d",
+                              ip, loport );
 
-                TAB_APPEND( rtsp->i_id, rtsp->id, id );
-                TAB_APPEND( rtsp->i_access, rtsp->access, p_access );
+                    p_access = sout_AccessOutNew( p_stream->p_sout,
+                                                  psz_access, url );
+                    if( p_access == NULL )
+                    {
+                        msg_Err( p_stream,
+                                 "cannot create access output for %s://%s",
+                                 psz_access, url );
+                        answer->i_status = 500;
+                        break;
+                    }
 
-                answer->i_status = 200;
-                answer->psz_status = strdup( "OK" );
-                answer->i_body = 0;
-                answer->p_body = NULL;
+                    TAB_APPEND( rtsp->i_id, rtsp->id, id );
+                    TAB_APPEND( rtsp->i_access, rtsp->access, p_access );
 
-                httpd_MsgAdd( answer, "Transport",
-                              "RTP/AVP/UDP;client_port=%d-%d", i_port, i_port + 1 );
-            }
-            else /* TODO  strstr( psz_transport, "interleaved" ) ) */
-            {
-                answer->i_status = 461;
-                answer->psz_status = strdup( "Unsupported Transport" );
-                answer->i_body = 0;
-                answer->p_body = NULL;
+                    char *src = var_GetNonEmptyString (p_access, "src-addr");
+                    int sport = var_GetInteger (p_access, "src-port");
+
+                    httpd_ServerIP( cl, ip );
+                    fprintf( stderr, "src = %s, ip = %s\n", src, ip );
+
+                    if( ( src != NULL ) && strcmp( src, ip ) )
+                    {
+                        /* Specify source IP if it is different from the RTSP
+                         * control connection server address */
+                        httpd_MsgAdd( answer, "Transport",
+                                      "RTP/AVP/UDP;unicast;source=%s;"
+                                      "client_port=%u-%u;server_port=%u-%u",
+                                      src, loport, hiport, sport, sport + 1 );
+                    }
+                    else
+                    {
+                        httpd_MsgAdd( answer, "Transport",
+                                      "RTP/AVP/UDP;unicast;"
+                                      "client_port=%u-%u;server_port=%u-%u",
+                                      loport, hiport, sport, sport + 1 );
+                    }
+
+                    answer->i_status = 200;
+                    free( src );
+                }
+                break;
             }
             break;
         }
 
         default:
+            answer->i_status = 460;
+            break;
+
             return VLC_EGENERIC;
     }
-    httpd_MsgAdd( answer, "Server", "VLC Server" );
+
+    httpd_MsgAdd( answer, "Server", PACKAGE_STRING );
     httpd_MsgAdd( answer, "Content-Length", "%d", answer->i_body );
     psz_cseq = httpd_MsgGet( query, "Cseq" );
-    if( psz_cseq )
-        i_cseq = atoi( psz_cseq );
-    else
-        i_cseq = 0;
-    httpd_MsgAdd( answer, "Cseq", "%d", i_cseq );
+    httpd_MsgAdd( answer, "Cseq", "%s", psz_cseq ? psz_cseq : "0");
     httpd_MsgAdd( answer, "Cache-Control", "%s", "no-cache" );
 
     if( psz_session )
-    {
         httpd_MsgAdd( answer, "Session", "%s"/*;timeout=5*/, psz_session );
-    }
     return VLC_SUCCESS;
 }
 
@@ -2481,108 +2490,117 @@ static int rtp_packetize_h263( sout_stream_t *p_stream, sout_stream_id_t *id,
 }
 
 /* rfc3984 */
-static int rtp_packetize_h264( sout_stream_t *p_stream, sout_stream_id_t *id,
-                               block_t *in )
+static int rtp_packetize_h264_nal( sout_stream_t *p_stream, sout_stream_id_t *id,
+                                   const uint8_t *p_data, int i_data, int64_t i_pts, int64_t i_dts, vlc_bool_t b_last, int64_t i_length )
 {
-    int     i_max   = id->i_mtu - 12; /* payload max in one packet */
-    int     i_count = ( in->i_buffer + i_max - 1 ) / i_max;
-    uint8_t *p_data = in->p_buffer;
-    int     i_data  = in->i_buffer;
-    block_t *out;
-    int     i_nal_type;
-    int     i_payload;
-
-    while( i_data > 5 &&
-           ( p_data[0] != 0x00 || p_data[1] != 0x00 || p_data[2] != 0x01 || /* startcode */
-            (p_data[3]&0x1f) < 1 || (p_data[3]&0x1f) > 23 ) ) /* naltype should be between 1 and 23 */
-    {
-        p_data++;
-        i_data--;
-    }
+    const int i_max = id->i_mtu - 12; /* payload max in one packet */
+    int i_nal_hdr;
+    int i_nal_type;
 
     if( i_data < 5 )
         return VLC_SUCCESS;
 
-    p_data+=3;
-    i_data-=3;
-    i_nal_type = p_data[0]&0x1f;
-
-    /* Skip global headers */
+    i_nal_hdr = p_data[3];
+    i_nal_type = i_nal_hdr&0x1f;
     if( i_nal_type == 7 || i_nal_type == 8 )
-        return VLC_SUCCESS;
-    
-    if( i_data <= i_max ) /* The whole pack will fit in one rtp payload */
     {
-        /* single NAL */
-        i_payload = __MIN( i_max, i_data );
-        out = block_New( p_stream, 12 + i_payload );
+        /* XXX Why do you want to remove them ? It will break streaming with 
+         * SPS/PPS change (broadcast) ? */
+        return VLC_SUCCESS;
+    }
 
-        /* rtp common header */
-        rtp_packetize_common( id, out, 1,
-                              in->i_pts > 0 ? in->i_pts : in->i_dts );
+    /* Skip start code */
+    p_data += 3;
+    i_data -= 3;
 
-        memcpy( &out->p_buffer[12], p_data, i_payload );
+    /* */
+    if( i_data <= i_max )
+    {
+        /* Single NAL unit packet */
+        block_t *out = block_New( p_stream, 12 + i_data );
+        out->i_dts    = i_dts;
+        out->i_length = i_length;
 
-        out->i_buffer   = 12 + i_payload;
-        out->i_dts    = in->i_dts;
-        out->i_length = in->i_length;
+        /* */
+        rtp_packetize_common( id, out, b_last, i_pts );
+        out->i_buffer = 12 + i_data;
 
-        rtp_packetize_send( id, out );
+        memcpy( &out->p_buffer[12], p_data, i_data );
 
-        /*msg_Dbg( p_stream, "nal-out plain %d %02x", i_payload, out->p_buffer[16] );*/
+        rtp_packetize_send( id, out );
     }
     else
     {
-        /* FU-A */
-        uint8_t     nalh; /* The nalheader byte */
-        int i=0, start=1, end=0, first=0;
-        nalh = *p_data;
+        /* FU-A Fragmentation Unit without interleaving */
+        const int i_count = ( i_data-1 + i_max-2 - 1 ) / (i_max-2);
+        int i;
+
         p_data++;
         i_data--;
 
-        i_max   = id->i_mtu - 14;
-        i_count = ( i_data + i_max - 1 ) / i_max;
-
-        /*msg_Dbg( p_stream, "nal-out fragmented %02x %d", nalh, i_rest);*/
-
-        while( end == 0 )
+        for( i = 0; i < i_count; i++ )
         {
-            i_payload = __MIN( i_max, i_data );
-            out = block_New( p_stream, 14 + i_payload );
-
-            if( i_data == i_payload )
-                end = 1;
+            const int i_payload = __MIN( i_data, i_max-2 );
+            block_t *out = block_New( p_stream, 12 + 2 + i_payload );
+            out->i_dts    = i_dts + i * i_length / i_count;
+            out->i_length = i_length / i_count;
 
-            /* rtp common header */
-            rtp_packetize_common( id, out, (end)?1:0,
-                              in->i_pts > 0 ? in->i_pts : in->i_dts );
+            /* */
+            rtp_packetize_common( id, out, (b_last && i_payload == i_data), i_pts );
+            out->i_buffer = 14 + i_payload;
 
             /* FU indicator */
-            out->p_buffer[12] = (nalh&0x60)|28;
+            out->p_buffer[12] = 0x00 | (i_nal_hdr & 0x60) | 28;
             /* FU header */
-            out->p_buffer[13] = (start<<7)|(end<<6)|(nalh&0x1f);
+            out->p_buffer[13] = ( i == 0 ? 0x80 : 0x00 ) | ( (i == i_count-1) ? 0x40 : 0x00 )  | i_nal_type;
+            memcpy( &out->p_buffer[14], p_data, i_payload );
 
-            memcpy( &out->p_buffer[14], p_data+first, i_payload );
-            out->i_buffer   = 14 + i_payload;
+            rtp_packetize_send( id, out );
 
-            // not sure what of these should be used and what it does :)
-            out->i_pts    = in->i_pts;
-            out->i_dts    = in->i_dts;
-            //out->i_dts    = in->i_dts + i * in->i_length / i_count;
-            //out->i_length = in->i_length / i_count;
+            i_data -= i_payload;
+            p_data += i_payload;
+        }
+    }
+    return VLC_SUCCESS;
+}
 
-            rtp_packetize_send( id, out );
+static int rtp_packetize_h264( sout_stream_t *p_stream, sout_stream_id_t *id,
+                               block_t *in )
+{
+    const uint8_t *p_buffer = in->p_buffer;
+    int i_buffer = in->i_buffer;
 
-            /*msg_Dbg( p_stream, "nal-out fragmented: frag %d %d %02x %02x %d", start,end,
-            out->p_buffer[12], out->p_buffer[13], i_payload );*/
+    while( i_buffer > 4 && ( p_buffer[0] != 0 || p_buffer[1] != 0 || p_buffer[2] != 1 ) )
+    {
+        i_buffer--;
+        p_buffer++;
+    }
 
-            i_data -= i_payload;
-            first += i_payload;
-            i++;
-            start=0;
+    /* Split nal units */
+    while( i_buffer > 4 )
+    {
+        int i_offset;
+        int i_size = i_buffer;
+        int i_skip = i_buffer;
+
+        /* search nal end */
+        for( i_offset = 4; i_offset+2 < i_buffer ; i_offset++)
+        {
+            if( p_buffer[i_offset] == 0 && p_buffer[i_offset+1] == 0 && p_buffer[i_offset+2] == 1 )
+            {
+                /* we found another startcode */
+                i_size = i_offset - ( p_buffer[i_offset-1] == 0 ? 1 : 0);
+                i_skip = i_offset;
+                break;
+            } 
         }
+        /* TODO add STAP-A to remove a lot of overhead with small slice/sei/... */
+        rtp_packetize_h264_nal( p_stream, id, p_buffer, i_size,
+                                (in->i_pts > 0 ? in->i_pts : in->i_dts), in->i_dts,
+                                (i_size >= i_buffer), in->i_length * i_size / in->i_buffer );
+
+        i_buffer -= i_skip;
+        p_buffer += i_skip;
     }
     return VLC_SUCCESS;
 }