]> git.sesse.net Git - vlc/blobdiff - modules/access/mms/mmsh.c
Removed useless ACCESS_GET_MTU/STREAM_GET_MTU.
[vlc] / modules / access / mms / mmsh.c
index 71bd20f2ea64ebeb40f9d81388f4a966d1fbf00f..95bbdea078cb5f7e0c150d191d2de0585699efae 100644 (file)
 # include "config.h"
 #endif
 
-#include <vlc/vlc.h>
+#include <vlc_common.h>
 #include <vlc_access.h>
-#include "vlc_playlist.h"
 #include "vlc_strings.h"
+#include "vlc_input.h"
 
 #include <vlc_network.h>
 #include "vlc_url.h"
 /*****************************************************************************
  * Local prototypes
  *****************************************************************************/
-int  E_(MMSHOpen)  ( access_t * );
-void E_(MMSHClose) ( access_t * );
+int  MMSHOpen  ( access_t * );
+void MMSHClose ( access_t * );
 
-static ssize_t Read( access_t *, uint8_t *, size_t );
+static block_t *Block( access_t *p_access );
 static ssize_t ReadRedirect( access_t *, uint8_t *, size_t );
 static int  Seek( access_t *, int64_t );
 static int  Control( access_t *, int, va_list );
@@ -73,37 +73,19 @@ static int Reset( access_t * );
 /****************************************************************************
  * Open: connect to ftp server and ask for file
  ****************************************************************************/
-int E_(MMSHOpen)( access_t *p_access )
+int MMSHOpen( access_t *p_access )
 {
     access_sys_t    *p_sys;
     char            *psz_location = NULL;
     char            *psz_proxy;
 
-    /* init p_sys */
-
-    /* Set up p_access */
-    p_access->pf_read = Read;
-    p_access->pf_block = NULL;
-    p_access->pf_control = Control;
-    p_access->pf_seek = Seek;
-    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 ) );
-    if( !p_sys )
-        return VLC_ENOMEM;
-
-    memset( p_sys, 0, sizeof( access_sys_t ) );
+    STANDARD_BLOCK_ACCESS_INIT
+
     p_sys->i_proto= MMS_PROTO_HTTP;
     p_sys->fd     = -1;
-    p_sys->i_start= 0;
 
     /* Handle proxy */
-    p_sys->b_proxy = VLC_FALSE;
+    p_sys->b_proxy = false;
     memset( &p_sys->proxy, 0, sizeof(p_sys->proxy) );
 
     /* Check proxy */
@@ -126,7 +108,7 @@ int E_(MMSHOpen)( access_t *p_access )
 
     if( *psz_proxy )
     {
-        p_sys->b_proxy = VLC_TRUE;
+        p_sys->b_proxy = true;
         vlc_UrlParse( &p_sys->proxy, psz_proxy, 0 );
     }
 #ifdef HAVE_GETENV
@@ -135,7 +117,7 @@ int E_(MMSHOpen)( access_t *p_access )
         char *psz_proxy = getenv( "http_proxy" );
         if( psz_proxy && *psz_proxy )
         {
-            p_sys->b_proxy = VLC_TRUE;
+            p_sys->b_proxy = true;
             vlc_UrlParse( &p_sys->proxy, psz_proxy, 0 );
         }
     }
@@ -183,20 +165,29 @@ int E_(MMSHOpen)( access_t *p_access )
     /* Handle redirection */
     if( psz_location && *psz_location )
     {
-        playlist_t * p_playlist = pl_Yield( p_access );
         msg_Dbg( p_access, "redirection to %s", psz_location );
 
+        input_thread_t * p_input = vlc_object_find( p_access, VLC_OBJECT_INPUT, FIND_PARENT );
+        input_item_t * p_new_loc;
+
+        if( !p_input )
+        {
+            free( psz_location );
+            return VLC_EGENERIC;
+        }
         /** \bug we do not autodelete here */
-        playlist_Add( p_playlist, psz_location, psz_location,
-                      PLAYLIST_INSERT | PLAYLIST_GO, PLAYLIST_END, VLC_TRUE,
-                      VLC_FALSE );
-        vlc_object_release( p_playlist );
+        p_new_loc = input_item_New( p_access, psz_location, psz_location );
+        input_item_AddSubItem( input_GetItem( p_input ), p_new_loc );
+        vlc_gc_decref( p_new_loc );
+        vlc_object_release( p_input );
 
         free( psz_location );
 
+        p_access->pf_block = NULL;
         p_access->pf_read = ReadRedirect;
         return VLC_SUCCESS;
     }
+    free( psz_location );
 
     /* Start playing */
     if( Start( p_access, 0 ) )
@@ -220,14 +211,13 @@ int E_(MMSHOpen)( access_t *p_access )
 /*****************************************************************************
  * Close: free unused data structures
  *****************************************************************************/
-void E_( MMSHClose )( access_t *p_access )
+void  MMSHClose ( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
     Stop( p_access );
 
-    if( p_sys->p_header )
-        free( p_sys->p_header  );
+    free( p_sys->p_header  );
 
     vlc_UrlClean( &p_sys->proxy );
     vlc_UrlClean( &p_sys->url );
@@ -240,8 +230,8 @@ void E_( MMSHClose )( access_t *p_access )
 static int Control( access_t *p_access, int i_query, va_list args )
 {
     access_sys_t *p_sys = p_access->p_sys;
-    vlc_bool_t   *pb_bool;
-    int          *pi_int;
+    bool   *pb_bool;
+    bool    b_bool;
     int64_t      *pi_64;
     int          i_int;
 
@@ -249,43 +239,45 @@ static int Control( access_t *p_access, int i_query, va_list args )
     {
         /* */
         case ACCESS_CAN_SEEK:
-            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
+            pb_bool = (bool*)va_arg( args, bool* );
             *pb_bool = !p_sys->b_broadcast;
             break;
 
         case ACCESS_CAN_FASTSEEK:
-        case ACCESS_CAN_PAUSE:
-            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
-            *pb_bool = VLC_FALSE;
+            pb_bool = (bool*)va_arg( args, bool* );
+            *pb_bool = false;
             break;
 
+        case ACCESS_CAN_PAUSE:
         case ACCESS_CAN_CONTROL_PACE:
-            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
-            *pb_bool = VLC_TRUE;
+            pb_bool = (bool*)va_arg( args, bool* );
+            *pb_bool = true;
             break;
 
         /* */
-        case ACCESS_GET_MTU:
-            pi_int = (int*)va_arg( args, int * );
-            *pi_int = 3 * p_sys->asfh.i_min_data_packet_size;
-            break;
-
         case ACCESS_GET_PTS_DELAY:
             pi_64 = (int64_t*)va_arg( args, int64_t * );
-            *pi_64 = (int64_t)var_GetInteger( p_access, "mms-caching" ) * I64C(1000);
+            *pi_64 = (int64_t)var_GetInteger( p_access, "mms-caching" ) * INT64_C(1000);
             break;
 
         case ACCESS_GET_PRIVATE_ID_STATE:
             i_int = (int)va_arg( args, int );
-            pb_bool = (vlc_bool_t *)va_arg( args, vlc_bool_t * );
+            pb_bool = (bool *)va_arg( args, bool * );
 
             if( (i_int < 0) || (i_int > 127) )
                 return VLC_EGENERIC;
-            *pb_bool =  p_sys->asfh.stream[i_int].i_selected ? VLC_TRUE : VLC_FALSE;
+            *pb_bool =  p_sys->asfh.stream[i_int].i_selected ? true : false;
             break;
 
         /* */
         case ACCESS_SET_PAUSE_STATE:
+            b_bool = (bool)va_arg( args, int );
+            if( b_bool )
+                Stop( p_access );
+            else
+                Seek( p_access, p_access->info.i_pos );
+            break;
+
         case ACCESS_GET_TITLE_INFO:
         case ACCESS_SET_TITLE:
         case ACCESS_SET_SEEKPOINT:
@@ -311,7 +303,7 @@ static int Seek( access_t *p_access, int64_t i_pos )
     off_t        i_offset;
     off_t        i_packet;
 
-    msg_Dbg( p_access, "seeking to "I64Fd, i_pos );
+    msg_Dbg( p_access, "seeking to %"PRId64, i_pos );
 
     i_packet = ( i_pos - p_sys->i_header ) / p_sys->asfh.i_min_data_packet_size;
     i_offset = ( i_pos - p_sys->i_header ) % p_sys->asfh.i_min_data_packet_size;
@@ -319,9 +311,8 @@ static int Seek( access_t *p_access, int64_t i_pos )
     Stop( p_access );
     Start( p_access, i_packet * p_sys->asfh.i_min_data_packet_size );
 
-    while( !p_access->b_die )
+    while( vlc_object_alive (p_access) )
     {
-        msg_Warn( p_access, "GetPacket 1" );
         if( GetPacket( p_access, &ck ) )
             break;
 
@@ -333,96 +324,92 @@ static int Seek( access_t *p_access, int64_t i_pos )
     }
 
     p_access->info.i_pos = i_pos;
-    p_access->info.b_eof = VLC_FALSE;
+    p_access->info.b_eof = false;
     p_sys->i_packet_used += i_offset;
 
     return VLC_SUCCESS;
 }
 
 /*****************************************************************************
- * Read:
+ * ReadRedirect:
  *****************************************************************************/
 static ssize_t ReadRedirect( access_t *p_access, uint8_t *p, size_t i_len )
 {
+    VLC_UNUSED(p_access); VLC_UNUSED(p); VLC_UNUSED(i_len);
     return 0;
 }
 
 /*****************************************************************************
- * Read:
+ * Block:
  *****************************************************************************/
-static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len )
+static block_t *Block( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
-    size_t       i_copy;
-    size_t       i_data = 0;
+    const unsigned i_packet_min = p_sys->asfh.i_min_data_packet_size;
+
+    if( p_access->info.i_pos < p_sys->i_start + p_sys->i_header )
+    {
+        const size_t i_offset = p_access->info.i_pos - p_sys->i_start;
+        const size_t i_copy = p_sys->i_header - i_offset;
 
-    if( p_access->info.b_eof )
-        return 0;
+        block_t *p_block = block_New( p_access, i_copy );
+        if( !p_block )
+            return NULL;
 
-    while( i_data < (size_t) i_len )
+        memcpy( p_block->p_buffer, &p_sys->p_header[i_offset], i_copy );
+        p_access->info.i_pos += i_copy;
+        return p_block;
+    }
+    else if( p_sys->i_packet_length > 0 &&
+             p_sys->i_packet_used < __MAX( p_sys->i_packet_length, i_packet_min ) )
     {
-        if( p_access->info.i_pos < (p_sys->i_start + p_sys->i_header) )
-        {
-            int i_offset = p_access->info.i_pos - p_sys->i_start;
-            i_copy = __MIN( p_sys->i_header - i_offset,
-                            (int)((size_t)i_len - i_data) );
-            memcpy( &p_buffer[i_data], &p_sys->p_header[i_offset], i_copy );
+        size_t i_copy = 0;
+        size_t i_padding = 0;
 
-            i_data += i_copy;
-            p_access->info.i_pos += i_copy;
-        }
-        else if( p_sys->i_packet_used < p_sys->i_packet_length )
-        {
-            i_copy = __MIN( p_sys->i_packet_length - p_sys->i_packet_used,
-                            i_len - i_data );
-            memcpy( &p_buffer[i_data],
-                    &p_sys->p_packet[p_sys->i_packet_used],
-                    i_copy );
-
-            i_data += i_copy;
-            p_sys->i_packet_used += i_copy;
-            p_access->info.i_pos += i_copy;
-        }
-        else if( (p_sys->i_packet_length > 0) &&
-                 ((int)p_sys->i_packet_used < p_sys->asfh.i_min_data_packet_size) )
-        {
-            i_copy = __MIN( p_sys->asfh.i_min_data_packet_size - p_sys->i_packet_used,
-                            i_len - i_data );
-            memset( &p_buffer[i_data], 0, i_copy );
+        if( p_sys->i_packet_used < p_sys->i_packet_length )
+            i_copy = p_sys->i_packet_length - p_sys->i_packet_used;
+        if( __MAX( p_sys->i_packet_used, p_sys->i_packet_length ) < i_packet_min )
+            i_padding = i_packet_min - __MAX( p_sys->i_packet_used, p_sys->i_packet_length );
+
+        block_t *p_block = block_New( p_access, i_copy + i_padding );
+        if( !p_block )
+            return NULL;
 
-            i_data += i_copy;
-            p_sys->i_packet_used += i_copy;
-            p_access->info.i_pos += i_copy;
+        if( i_copy > 0 )
+            memcpy( &p_block->p_buffer[0], &p_sys->p_packet[p_sys->i_packet_used], i_copy );
+        if( i_padding > 0 )
+            memset( &p_block->p_buffer[i_copy], 0, i_padding );
+
+        p_sys->i_packet_used += i_copy + i_padding;
+        p_access->info.i_pos += i_copy + i_padding;
+        return p_block;
+
+    }
+
+    chunk_t ck;
+    if( GetPacket( p_access, &ck ) )
+    {
+        int i_ret = -1;
+        if( p_sys->b_broadcast )
+        {
+            if( (ck.i_type == 0x4524) && (ck.i_sequence != 0) )
+                i_ret = Restart( p_access );
+            else if( ck.i_type == 0x4324 )
+                i_ret = Reset( p_access );
         }
-        else
+        if( i_ret )
         {
-            chunk_t ck;
-        msg_Warn( p_access, "GetPacket 2" );
-            if( GetPacket( p_access, &ck ) )
-            {
-                int i_ret = -1;
-                if( p_sys->b_broadcast )
-                {
-                    if( (ck.i_type == 0x4524) && (ck.i_sequence != 0) )
-                        i_ret = Restart( p_access );
-                    else if( ck.i_type == 0x4324 )
-                        i_ret = Reset( p_access );
-                }
-                if( i_ret )
-                {
-                    p_access->info.b_eof = VLC_TRUE;
-                    return 0;
-                }
-            }
-            if( ck.i_type != 0x4424 )
-            {
-                p_sys->i_packet_used = 0;
-                p_sys->i_packet_length = 0;
-            }
+            p_access->info.b_eof = true;
+            return 0;
         }
     }
+    if( ck.i_type != 0x4424 )
+    {
+        p_sys->i_packet_used = 0;
+        p_sys->i_packet_length = 0;
+    }
 
-    return( i_data );
+    return NULL;
 }
 
 /* */
@@ -473,13 +460,13 @@ static int Reset( access_t *p_access )
     if( p_sys->i_header <= 0 )
         return VLC_EGENERIC;
 
-    E_( asf_HeaderParse )( &p_sys->asfh,
+     asf_HeaderParse ( &p_sys->asfh,
                            p_sys->p_header, p_sys->i_header );
-    msg_Dbg( p_access, "packet count="I64Fd" packet size=%d",
+    msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
              p_sys->asfh.i_data_packets_count,
              p_sys->asfh.i_min_data_packet_size );
 
-    E_( asf_StreamSelect)( &p_sys->asfh,
+     asf_StreamSelect( &p_sys->asfh,
                            var_CreateGetInteger( p_access, "mms-maxbitrate" ),
                            var_CreateGetInteger( p_access, "mms-all" ),
                            var_CreateGetInteger( p_access, "audio" ),
@@ -534,8 +521,9 @@ static int OpenConnection( access_t *p_access )
             char *buf;
             char *b64;
 
-            asprintf( &buf, "%s:%s", p_sys->proxy.psz_username,
-                       p_sys->proxy.psz_password ? p_sys->proxy.psz_password : "" );
+            if( asprintf( &buf, "%s:%s", p_sys->proxy.psz_username,
+                       p_sys->proxy.psz_password ? p_sys->proxy.psz_password : "" ) == -1 )
+                return VLC_ENOMEM;
 
             b64 = vlc_b64_encode( buf );
             free( buf );
@@ -569,13 +557,13 @@ static int Describe( access_t  *p_access, char **ppsz_location )
     int          i_code;
 
     /* Reinit context */
-    p_sys->b_broadcast = VLC_TRUE;
+    p_sys->b_broadcast = true;
     p_sys->i_request_context = 1;
     p_sys->i_packet_sequence = 0;
     p_sys->i_packet_used = 0;
     p_sys->i_packet_length = 0;
     p_sys->p_packet = NULL;
-    E_( GenerateGuid )( &p_sys->guid );
+     GenerateGuid ( &p_sys->guid );
 
     if( OpenConnection( p_access ) )
         return VLC_EGENERIC;
@@ -654,17 +642,17 @@ static int Describe( access_t  *p_access, char **ppsz_location )
                 if( strstr( p, "broadcast" ) )
                 {
                     msg_Dbg( p_access, "stream type = broadcast" );
-                    p_sys->b_broadcast = VLC_TRUE;
+                    p_sys->b_broadcast = true;
                 }
                 else if( strstr( p, "seekable" ) )
                 {
                     msg_Dbg( p_access, "stream type = seekable" );
-                    p_sys->b_broadcast = VLC_FALSE;
+                    p_sys->b_broadcast = false;
                 }
                 else
                 {
                     msg_Warn( p_access, "unknow stream types (%s)", p );
-                    p_sys->b_broadcast = VLC_FALSE;
+                    p_sys->b_broadcast = false;
                 }
             }
         }
@@ -704,13 +692,16 @@ static int Describe( access_t  *p_access, char **ppsz_location )
      *
      * TODO : stream bitrates properties(optional)
      *        and bitrate mutual exclusion(optional) */
-    E_( asf_HeaderParse )( &p_sys->asfh,
+     asf_HeaderParse ( &p_sys->asfh,
                            p_sys->p_header, p_sys->i_header );
-    msg_Dbg( p_access, "packet count="I64Fd" packet size=%d",
+    msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
              p_sys->asfh.i_data_packets_count,
              p_sys->asfh.i_min_data_packet_size );
 
-    E_( asf_StreamSelect)( &p_sys->asfh,
+    if( p_sys->asfh.i_min_data_packet_size <= 0 )
+        goto error;
+
+     asf_StreamSelect( &p_sys->asfh,
                            var_CreateGetInteger( p_access, "mms-maxbitrate" ),
                            var_CreateGetInteger( p_access, "mms-all" ),
                            var_CreateGetInteger( p_access, "audio" ),
@@ -732,8 +723,7 @@ static void GetHeader( access_t *p_access )
 
     /* Read the asf header */
     p_sys->i_header = 0;
-    if( p_sys->p_header )
-        free( p_sys->p_header  );
+    free( p_sys->p_header  );
     p_sys->p_header = NULL;
     for( ;; )
     {
@@ -756,7 +746,7 @@ static void GetHeader( access_t *p_access )
 /*****************************************************************************
  * Start stream
  ****************************************************************************/
-static int Start( access_t *p_access, off_t i_pos )
+static int Start( access_t *p_access, int64_t i_pos )
 {
     access_sys_t *p_sys = p_access->p_sys;
     int  i_streams = 0;
@@ -903,7 +893,7 @@ static int GetPacket( access_t * p_access, chunk_t *p_ck )
      * (4 bytes), decode and then read up to 8 additional bytes to get the
      * entire header.
      */
-    if( net_Read( p_access, p_sys->fd, NULL, p_sys->buffer, 4, VLC_TRUE ) < 4 )
+    if( net_Read( p_access, p_sys->fd, NULL, p_sys->buffer, 4, true ) < 4 )
     {
        msg_Err( p_access, "cannot read data 2" );
        return VLC_EGENERIC;
@@ -916,7 +906,7 @@ static int GetPacket( access_t * p_access, chunk_t *p_ck )
     if( restsize > 8 )
         restsize = 8;
 
-    if( net_Read( p_access, p_sys->fd, NULL, p_sys->buffer + 4, restsize, VLC_TRUE ) < restsize )
+    if( net_Read( p_access, p_sys->fd, NULL, p_sys->buffer + 4, restsize, true ) < restsize )
     {
         msg_Err( p_access, "cannot read data 3" );
         return VLC_EGENERIC;
@@ -963,7 +953,7 @@ static int GetPacket( access_t * p_access, chunk_t *p_ck )
 
     if( (p_ck->i_data > 0) &&
         (net_Read( p_access, p_sys->fd, NULL, &p_sys->buffer[12],
-                   p_ck->i_data, VLC_TRUE ) < p_ck->i_data) )
+                   p_ck->i_data, true ) < p_ck->i_data) )
     {
         msg_Err( p_access, "cannot read data 4" );
         return VLC_EGENERIC;