* udp: converted to access2 (using pf_block, so for now it may hurt a

bit the perfs as we do a memcpy in access2.c)

modules/access/access2.c

@@ -44,12 +44,18 @@ vlc_module_begin();
     add_shortcut( "ftp" );
     add_shortcut( "tcp" );
     add_shortcut( "pvr" );
+
     add_shortcut( "file" );
     add_shortcut( "stream" );
     add_shortcut( "kfir" );
 
-    /* Hack */
-    //add_shortcut( "file" );
+    add_shortcut( "udp" );
+    add_shortcut( "udp4" );
+    add_shortcut( "udp6" );
+
+    add_shortcut( "rtp" );
+    add_shortcut( "rtp4" );
+    add_shortcut( "rtp6" );
 vlc_module_end();
 
 /*****************************************************************************
@@ -68,6 +74,8 @@ typedef struct
     int i_title;
     input_title_t **title;
 
+    vlc_bool_t b_first_read;
+
 } access2_sys_t;
 
 /*****************************************************************************
@@ -183,6 +191,7 @@ static int Access2Open( vlc_object_t * p_this )
 
     p_sys->p_access = p_access;
     p_sys->p_block = NULL;
+    p_sys->b_first_read = VLC_TRUE;
 
     return VLC_SUCCESS;
 }
@@ -252,10 +261,14 @@ static int  Access2Read( input_thread_t *p_input, byte_t *p_buffer, size_t i_len
         }
 
         i_copy = __MIN( i_len - i_total, p_sys->p_block->i_buffer );
+        if( i_copy > 0 )
+        {
             memcpy( &p_buffer[i_total], p_sys->p_block->p_buffer, i_copy );
 
             p_sys->p_block->i_buffer -= i_copy;
             p_sys->p_block->p_buffer += i_copy;
+        }
+
         if( p_sys->p_block->i_buffer <= 0 )
         {
             block_Release( p_sys->p_block );
@@ -265,6 +278,16 @@ static int  Access2Read( input_thread_t *p_input, byte_t *p_buffer, size_t i_len
         i_total += i_copy;
     }
 update:
+    if( p_sys->b_first_read )
+    {
+        /* Some access update it only after first read (like udp) */
+        if( p_access->psz_demux && *p_access->psz_demux )
+        {
+            if( !p_input->psz_demux || *p_input->psz_demux == '\0' )
+                p_input->psz_demux = strdup( p_access->psz_demux );
+        }
+        p_sys->b_first_read = VLC_FALSE;
+    }
     if( p_access->info.i_update & INPUT_UPDATE_SIZE )
     {
         vlc_mutex_lock( &p_input->stream.stream_lock );

modules/access/udp.c

@@ -43,6 +43,10 @@
     "Allows you to modify the default caching value for UDP streams. This " \
     "value should be set in millisecond units." )
 
+#define AUTO_MTU_TEXT N_("Autodetection of MTU")
+#define AUTO_MTU_LONGTEXT N_( \
+    "Allows growing the MTU if truncated packets are found" )
+
 static int  Open ( vlc_object_t * );
 static void Close( vlc_object_t * );
 
@@ -51,8 +55,10 @@ vlc_module_begin();
 
     add_integer( "udp-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT,
                  CACHING_LONGTEXT, VLC_TRUE );
+    add_bool( "udp-auto-mtu", 0, NULL,
+              AUTO_MTU_TEXT, AUTO_MTU_LONGTEXT, VLC_TRUE );
 
-    set_capability( "access", 0 );
+    set_capability( "access2", 0 );
     add_shortcut( "udp" );
     add_shortcut( "udpstream" );
     add_shortcut( "udp4" );
@@ -68,13 +74,17 @@ vlc_module_end();
  *****************************************************************************/
 #define RTP_HEADER_LEN 12
 
-static ssize_t Read    ( input_thread_t *, byte_t *, size_t );
-static ssize_t RTPRead ( input_thread_t *, byte_t *, size_t );
-static ssize_t RTPChoose( input_thread_t *, byte_t *, size_t );
+static block_t *BlockUDP( access_t * );
+static block_t *BlockRTP( access_t * );
+static block_t *BlockChoose( access_t * );
+static int Control( access_t *, int, va_list );
 
 struct access_sys_t
 {
     int fd;
+
+    int i_mtu;
+    vlc_bool_t b_auto_mtu;
 };
 
 /*****************************************************************************
@@ -82,43 +92,44 @@ struct access_sys_t
  *****************************************************************************/
 static int Open( vlc_object_t *p_this )
 {
-    input_thread_t     *p_input = (input_thread_t *)p_this;
+    access_t     *p_access = (access_t*)p_this;
     access_sys_t *p_sys;
 
-    char *              psz_name = strdup(p_input->psz_name);
-    char *              psz_parser = psz_name;
-    char *              psz_server_addr = "";
-    char *              psz_server_port = "";
-    char *              psz_bind_addr = "";
-    char *              psz_bind_port = "";
-    int                 i_bind_port = 0, i_server_port = 0;
+    char *psz_name = strdup( p_access->psz_path );
+    char *psz_parser = psz_name;
+    char *psz_server_addr = "";
+    char *psz_server_port = "";
+    char *psz_bind_addr = "";
+    char *psz_bind_port = "";
+    int  i_bind_port = 0;
+    int  i_server_port = 0;
     vlc_value_t val;
 
 
     /* First set ipv4/ipv6 */
-    var_Create( p_input, "ipv4", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
-    var_Create( p_input, "ipv6", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
+    var_Create( p_access, "ipv4", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
+    var_Create( p_access, "ipv6", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 
-    if( *p_input->psz_access )
+    if( *p_access->psz_access )
     {
         /* Find out which shortcut was used */
-        if( !strncmp( p_input->psz_access, "udp4", 6 ) ||
-            !strncmp( p_input->psz_access, "rtp4", 6 ))
+        if( !strncmp( p_access->psz_access, "udp4", 6 ) ||
+            !strncmp( p_access->psz_access, "rtp4", 6 ))
         {
             val.b_bool = VLC_TRUE;
-            var_Set( p_input, "ipv4", val );
+            var_Set( p_access, "ipv4", val );
 
             val.b_bool = VLC_FALSE;
-            var_Set( p_input, "ipv6", val );
+            var_Set( p_access, "ipv6", val );
         }
-        else if( !strncmp( p_input->psz_access, "udp6", 6 ) ||
-                 !strncmp( p_input->psz_access, "rtp6", 6 ) )
+        else if( !strncmp( p_access->psz_access, "udp6", 6 ) ||
+                 !strncmp( p_access->psz_access, "rtp6", 6 ) )
         {
             val.b_bool = VLC_TRUE;
-            var_Set( p_input, "ipv6", val );
+            var_Set( p_access, "ipv6", val );
 
             val.b_bool = VLC_FALSE;
-            var_Set( p_input, "ipv4", val );
+            var_Set( p_access, "ipv4", val );
         }
     }
 
@@ -190,24 +201,32 @@ static int Open( vlc_object_t *p_this )
     i_server_port = strtol( psz_server_port, NULL, 10 );
     if( ( i_bind_port   = strtol( psz_bind_port,   NULL, 10 ) ) == 0 )
     {
-        i_bind_port = config_GetInt( p_this, "server-port" );
+        var_Create( p_access, "server-port", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+        var_Get( p_access, "server-port", &val  );
+        i_bind_port = val.i_int;
     }
 
-    msg_Dbg( p_input, "opening server=%s:%d local=%s:%d",
+    msg_Dbg( p_access, "opening server=%s:%d local=%s:%d",
              psz_server_addr, i_server_port, psz_bind_addr, i_bind_port );
 
-    p_sys = p_input->p_access_data = malloc( sizeof( access_sys_t ) );
-    if( p_sys == NULL )
-    {
-        msg_Err( p_input, "out of memory" );
-        return VLC_EGENERIC;
-    }
-
-    p_sys->fd = net_OpenUDP( p_input, psz_bind_addr, i_bind_port,
+    /* Set up p_access */
+    p_access->pf_read = NULL;
+    p_access->pf_block = BlockChoose;
+    p_access->pf_control = Control;
+    p_access->pf_seek = NULL;
+    p_access->info.i_update = 0;
+    p_access->info.i_size = 0;
+    p_access->info.i_pos = 0;
+    p_access->info.b_eof = VLC_FALSE;
+    p_access->info.i_title = 0;
+    p_access->info.i_seekpoint = 0;
+
+    p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
+    p_sys->fd = net_OpenUDP( p_access, psz_bind_addr, i_bind_port,
                                       psz_server_addr, i_server_port );
     if( p_sys->fd < 0 )
     {
-        msg_Err( p_input, "cannot open socket" );
+        msg_Err( p_access, "cannot open socket" );
         free( psz_name );
         free( p_sys );
         return VLC_EGENERIC;
@@ -215,27 +234,16 @@ static int Open( vlc_object_t *p_this )
     free( psz_name );
 
     /* FIXME */
-    var_Create( p_input, "mtu", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
-    var_Get( p_input, "mtu", &val);
-    p_input->i_mtu = val.i_int;
-
-    /* fill p_input fields */
-    p_input->pf_read = RTPChoose;
-    p_input->pf_set_program = input_SetProgram;
-    p_input->pf_set_area = NULL;
-    p_input->pf_seek = NULL;
-
-    vlc_mutex_lock( &p_input->stream.stream_lock );
-    p_input->stream.b_pace_control = VLC_FALSE;
-    p_input->stream.b_seekable = VLC_FALSE;
-    p_input->stream.p_selected_area->i_tell = 0;
-    p_input->stream.i_method = INPUT_METHOD_NETWORK;
-    vlc_mutex_unlock( &p_input->stream.stream_lock );
+    var_Create( p_access, "mtu", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    var_Get( p_access, "mtu", &val);
+    p_sys->i_mtu = val.i_int > 0 ? val.i_int : 1500;    /* avoid problem */
+
+    var_Create( p_access, "udp-auto-mtu", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
+    var_Get( p_access, "udp-auto-mtu", &val);
+    p_sys->b_auto_mtu = val.b_bool;
 
     /* Update default_pts to a suitable value for udp access */
-    var_Create( p_input, "udp-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
-    var_Get( p_input, "udp-caching", &val );
-    p_input->i_pts_delay = val.i_int * 1000;
+    var_Create( p_access, "udp-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 
     return VLC_SUCCESS;
 }
@@ -245,183 +253,199 @@ static int Open( vlc_object_t *p_this )
  *****************************************************************************/
 static void Close( vlc_object_t *p_this )
 {
-    input_thread_t *p_input = (input_thread_t *)p_this;
-    access_sys_t   *p_sys = p_input->p_access_data;
-
-    msg_Info( p_input, "closing UDP target `%s'", p_input->psz_source );
+    access_t     *p_access = (access_t*)p_this;
+    access_sys_t *p_sys = p_access->p_sys;
 
     net_Close( p_sys->fd );
-
     free( p_sys );
 }
 
 /*****************************************************************************
- * Read: read on a file descriptor, checking b_die periodically
+ * Control:
  *****************************************************************************/
-static ssize_t Read( input_thread_t * p_input, byte_t * p_buffer, size_t i_len )
+static int Control( access_t *p_access, int i_query, va_list args )
 {
-    access_sys_t   *p_sys = p_input->p_access_data;
+    access_sys_t *p_sys = p_access->p_sys;
+    vlc_bool_t   *pb_bool;
+    int          *pi_int;
+    int64_t      *pi_64;
+    vlc_value_t  val;
+
+    switch( i_query )
+    {
+        /* */
+        case ACCESS_CAN_SEEK:
+        case ACCESS_CAN_FASTSEEK:
+        case ACCESS_CAN_PAUSE:
+        case ACCESS_CAN_CONTROL_PACE:
+            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
+            *pb_bool = VLC_FALSE;
+            break;
+        /* */
+        case ACCESS_GET_MTU:
+            pi_int = (int*)va_arg( args, int * );
+            *pi_int = p_sys->i_mtu;
+            break;
+
+        case ACCESS_GET_PTS_DELAY:
+            pi_64 = (int64_t*)va_arg( args, int64_t * );
+            var_Get( p_access, "udp-caching", &val );
+            *pi_64 = val.i_int * 1000;
+            break;
 
-    return net_Read( p_input, p_sys->fd, p_buffer, i_len, VLC_FALSE );
+        /* */
+        case ACCESS_SET_PAUSE_STATE:
+        case ACCESS_GET_TITLE_INFO:
+        case ACCESS_SET_TITLE:
+        case ACCESS_SET_SEEKPOINT:
+            return VLC_EGENERIC;
+
+        default:
+            msg_Err( p_access, "unimplemented query in control" );
+            return VLC_EGENERIC;
+
+    }
+    return VLC_SUCCESS;
 }
 
 /*****************************************************************************
- * RTPRead : read from the network, and parse the RTP header
+ * BlockUDP:
  *****************************************************************************/
-static ssize_t RTPRead( input_thread_t * p_input, byte_t * p_buffer,
-                        size_t i_len )
+static block_t *BlockUDP( access_t *p_access )
+{
+    access_sys_t *p_sys = p_access->p_sys;
+    block_t      *p_block;
+
+    /* Read data */
+    p_block = block_New( p_access, p_sys->i_mtu );
+    p_block->i_buffer = net_Read( p_access, p_sys->fd, p_block->p_buffer, p_sys->i_mtu, VLC_FALSE );
+    if( p_block->i_buffer <= 0 )
+    {
+        block_Release( p_block );
+        return NULL;
+    }
+
+    if( p_block->i_buffer >= p_sys->i_mtu && p_sys->b_auto_mtu )
+    {
+        /* Increase by 10% */
+        p_sys->i_mtu += ( p_sys->i_mtu + 9 ) / 10;
+        msg_Dbg( p_access, "increasing MTU to %d", p_sys->i_mtu );
+    }
+
+    return p_block;
+}
+
+/*****************************************************************************
+ * BlockParseRTP/BlockRTP:
+ *****************************************************************************/
+static block_t *BlockParseRTP( access_t *p_access, block_t *p_block )
 {
     int     i_rtp_version;
     int     i_CSRC_count;
     int     i_payload_type;
     int     i_skip = 0;
 
-    byte_t *    p_tmp_buffer = alloca( p_input->i_mtu );
-
-    /* Get the raw data from the socket.
-     * We first assume that RTP header size is the classic RTP_HEADER_LEN. */
-    ssize_t i_ret = Read( p_input, p_tmp_buffer, p_input->i_mtu );
-
-    if ( i_ret <= 0 ) return 0; /* i_ret is at least 1 */
+    if( p_block->i_buffer < RTP_HEADER_LEN )
+        goto trash;
 
     /* Parse the header and make some verifications.
      * See RFC 1889 & RFC 2250. */
-
-    i_rtp_version  = ( p_tmp_buffer[0] & 0xC0 ) >> 6;
-    i_CSRC_count   = ( p_tmp_buffer[0] & 0x0F );
-    i_payload_type = ( p_tmp_buffer[1] & 0x7F );
+    i_rtp_version  = ( p_block->p_buffer[0] & 0xC0 ) >> 6;
+    i_CSRC_count   = ( p_block->p_buffer[0] & 0x0F );
+    i_payload_type = ( p_block->p_buffer[1] & 0x7F );
 
     if ( i_rtp_version != 2 )
-        msg_Dbg( p_input, "RTP version is %u, should be 2", i_rtp_version );
+        msg_Dbg( p_access, "RTP version is %u, should be 2", i_rtp_version );
 
     if( i_payload_type == 14 )
-    {
         i_skip = 4;
-    }
     else if( i_payload_type !=  33 && i_payload_type != 32 )
-    {
-        msg_Dbg( p_input, "unsupported RTP payload type (%u)",
-                 i_payload_type );
-    }
+        msg_Dbg( p_access, "unsupported RTP payload type (%u)", i_payload_type );
+
     i_skip += RTP_HEADER_LEN + 4*i_CSRC_count;
 
     /* A CSRC extension field is 32 bits in size (4 bytes) */
-    if ( i_ret < i_skip )
-    {
-        /* Packet is not big enough to hold the complete RTP_HEADER with
-         * CSRC extensions.
-         */
-        msg_Warn( p_input, "RTP input trashing %d bytes", i_ret - i_len );
-        return 0;
-    }
+    if( i_skip >= p_block->i_buffer )
+        goto trash;
 
     /* Return the packet without the RTP header. */
-    i_ret -= i_skip;
+    p_block->i_buffer -= i_skip;
+    p_block->p_buffer += i_skip;
 
-    if ( (size_t)i_ret > i_len )
-    {
-        /* This should NOT happen. */
-        msg_Warn( p_input, "RTP input trashing %d bytes", i_ret - i_len );
-        i_ret = i_len;
-    }
+    return p_block;
 
-    p_input->p_vlc->pf_memcpy( p_buffer, &p_tmp_buffer[i_skip], i_ret );
+trash:
+    msg_Warn( p_access, "received a too short packet for RTP" );
+    block_Release( p_block );
+    return NULL;
+}
 
-    return i_ret;
+static block_t *BlockRTP( access_t *p_access )
+{
+    return BlockParseRTP( p_access, BlockUDP( p_access ) );
 }
 
 /*****************************************************************************
- * RTPChoose : read from the network, and decide whether it's UDP or RTP
+ * BlockChoose: decide between RTP and UDP
  *****************************************************************************/
-static ssize_t RTPChoose( input_thread_t * p_input, byte_t * p_buffer,
-                          size_t i_len )
+static block_t *BlockChoose( access_t *p_access )
 {
+    block_t *p_block;
     int     i_rtp_version;
     int     i_CSRC_count;
     int     i_payload_type;
 
-    byte_t *    p_tmp_buffer = alloca( p_input->i_mtu );
+    if( ( p_block = BlockUDP( p_access ) ) == NULL )
+        return NULL;
 
-    /* Get the raw data from the socket.
-     * We first assume that RTP header size is the classic RTP_HEADER_LEN. */
-    ssize_t i_ret = Read( p_input, p_tmp_buffer, p_input->i_mtu );
-
-    if ( i_ret <= 0 ) return 0; /* i_ret is at least 1 */
-
-    /* Check that it's not TS. */
-    if ( p_tmp_buffer[0] == 0x47 )
+    if( p_block->p_buffer[0] == 0x47 )
     {
-        msg_Dbg( p_input, "detected TS over raw UDP" );
-        p_input->pf_read = Read;
-        p_input->p_vlc->pf_memcpy( p_buffer, p_tmp_buffer, i_ret );
-        return i_ret;
+        msg_Dbg( p_access, "detected TS over raw UDP" );
+        p_access->pf_block = BlockUDP;
+        return p_block;
     }
 
+    if( p_block->i_buffer < RTP_HEADER_LEN )
+        return p_block;
+
     /* Parse the header and make some verifications.
      * See RFC 1889 & RFC 2250. */
 
-    i_rtp_version  = ( p_tmp_buffer[0] & 0xC0 ) >> 6;
-    i_CSRC_count   = ( p_tmp_buffer[0] & 0x0F );
-    i_payload_type = ( p_tmp_buffer[1] & 0x7F );
+    i_rtp_version  = ( p_block->p_buffer[0] & 0xC0 ) >> 6;
+    i_CSRC_count   = ( p_block->p_buffer[0] & 0x0F );
+    i_payload_type = ( p_block->p_buffer[1] & 0x7F );
 
-    if ( i_rtp_version != 2 )
+    if( i_rtp_version != 2 )
     {
-        msg_Dbg( p_input, "no supported RTP header detected" );
-        p_input->pf_read = Read;
-        p_input->p_vlc->pf_memcpy( p_buffer, p_tmp_buffer, i_ret );
-        return i_ret;
+        msg_Dbg( p_access, "no supported RTP header detected" );
+        p_access->pf_block = BlockUDP;
+        return p_block;
     }
 
-    switch ( i_payload_type )
+    switch( i_payload_type )
     {
         case 33:
-        msg_Dbg( p_input, "detected TS over RTP" );
+            msg_Dbg( p_access, "detected TS over RTP" );
+            p_access->psz_demux = strdup( "ts2" );
             break;
 
         case 14:
-        msg_Dbg( p_input, "detected MPEG audio over RTP" );
-        if( !p_input->psz_demux || *p_input->psz_demux == '\0' )
-        {
-            p_input->psz_demux = "mp3";
-        }
+            msg_Dbg( p_access, "detected MPEG audio over RTP" );
+            p_access->psz_demux = strdup( "mp3" );
             break;
 
         case 32:
-        msg_Dbg( p_input, "detected MPEG video over RTP" );
+            msg_Dbg( p_access, "detected MPEG video over RTP" );
+            p_access->psz_demux = strdup( "es" );
             break;
 
         default:
-        msg_Dbg( p_input, "no RTP header detected" );
-        p_input->pf_read = Read;
-        p_input->p_vlc->pf_memcpy( p_buffer, p_tmp_buffer, i_ret );
-        return i_ret;
-    }
-
-    p_input->pf_read = RTPRead;
-
-    /* A CSRC extension field is 32 bits in size (4 bytes) */
-    if( i_ret < RTP_HEADER_LEN + 4*i_CSRC_count )
-    {
-        /* Packet is not big enough to hold the complete RTP_HEADER with
-         * CSRC extensions.
-         */
-        msg_Warn( p_input, "RTP input trashing %d bytes", i_ret - i_len );
-        return 0;
-    }
-
-    /* Return the packet without the RTP header. */
-    i_ret -= RTP_HEADER_LEN + 4*i_CSRC_count;
-
-    if ( (size_t)i_ret > i_len )
-    {
-        /* This should NOT happen. */
-        msg_Warn( p_input, "RTP input trashing %d bytes", i_ret - i_len );
-        i_ret = i_len;
+            msg_Dbg( p_access, "no RTP header detected" );
+            p_access->pf_block = BlockUDP;
+            return p_block;
     }
 
-    p_input->p_vlc->pf_memcpy( p_buffer,
-                               &p_tmp_buffer[RTP_HEADER_LEN + 4*i_CSRC_count],
-                               i_ret );
+    p_access->pf_block = BlockRTP;
 
-    return i_ret;
+    return BlockParseRTP( p_access, p_block );
 }