git.sesse.net Git - vlc/blob - modules/access/file.c

   1 /*****************************************************************************
   2  * file.c: file input (file: access plug-in)
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002 VideoLAN
   5  * $Id: file.c,v 1.21 2003/06/09 09:29:12 massiot Exp $
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <vlc/vlc.h>
  28 #include <vlc/input.h>
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #ifdef HAVE_SYS_TYPES_H
  33 #   include <sys/types.h>
  34 #endif
  35 #ifdef HAVE_SYS_TIME_H
  36 #   include <sys/time.h>
  37 #endif
  38 #ifdef HAVE_SYS_STAT_H
  39 #   include <sys/stat.h>
  40 #endif
  41 #ifdef HAVE_ERRNO_H
  42 #   include <errno.h>
  43 #endif
  44 #ifdef HAVE_FCNTL_H
  45 #   include <fcntl.h>
  46 #endif
  47
  48 #ifdef HAVE_UNISTD_H
  49 #   include <unistd.h>
  50 #elif defined( WIN32 ) && !defined( UNDER_CE )
  51 #   include <io.h>
  52 #endif
  53
  54 /* stat() support for large files on win32 */
  55 #if defined( WIN32 ) && !defined( UNDER_CE )
  56 #define stat(a,b) _stati64(a,b)
  57 #define fstat(a,b) _fstati64(a,b)
  58 #endif
  59
  60 /*****************************************************************************
  61  * Exported prototypes
  62  *****************************************************************************/
  63 static int     Open   ( vlc_object_t * );
  64 static void    Close  ( vlc_object_t * );
  65
  66 static void    Seek   ( input_thread_t *, off_t );
  67 static ssize_t Read   ( input_thread_t *, byte_t *, size_t );
  68
  69 /*****************************************************************************
  70  * Module descriptor
  71  *****************************************************************************/
  72 #define CACHING_TEXT N_("Caching value in ms")
  73 #define CACHING_LONGTEXT N_( \
  74     "Allows you to modify the default caching value for file streams. This " \
  75     "value should be set in miliseconds units." )
  76
  77 vlc_module_begin();
  78     set_description( _("Standard filesystem file input") );
  79     add_category_hint( N_("file"), NULL, VLC_TRUE );
  80     add_integer( "file-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
  81     set_capability( "access", 50 );
  82     add_shortcut( "file" );
  83     add_shortcut( "stream" );
  84     add_shortcut( "kfir" );
  85     set_callbacks( Open, Close );
  86 vlc_module_end();
  87
  88 /*****************************************************************************
  89  * _input_socket_t: private access plug-in data, modified to add private
  90  *                  fields
  91  *****************************************************************************/
  92 typedef struct _input_socket_s
  93 {
  94     input_socket_t      _socket;
  95
  96     unsigned int        i_nb_reads;
  97     vlc_bool_t          b_kfir;
  98 } _input_socket_t;
  99
 100 /*****************************************************************************
 101  * Open: open the file
 102  *****************************************************************************/
 103 static int Open( vlc_object_t *p_this )
 104 {
 105     input_thread_t *    p_input = (input_thread_t *)p_this;
 106     char *              psz_name = p_input->psz_name;
 107 #ifdef HAVE_SYS_STAT_H
 108     int                 i_stat;
 109 #if defined( WIN32 ) && !defined( UNDER_CE )
 110     struct _stati64     stat_info;
 111 #else
 112     struct stat         stat_info;
 113 #endif
 114 #endif
 115     _input_socket_t *   p_access_data;
 116     vlc_bool_t          b_stdin, b_kfir = 0;
 117
 118     p_input->i_mtu = 0;
 119
 120     b_stdin = psz_name[0] == '-' && psz_name[1] == '\0';
 121
 122 #ifdef HAVE_SYS_STAT_H
 123     if( !b_stdin && (i_stat = stat( psz_name, &stat_info )) == (-1) )
 124     {
 125 #   ifdef HAVE_ERRNO_H
 126         msg_Warn( p_input, "cannot stat() file `%s' (%s)",
 127                   psz_name, strerror(errno));
 128 #   else
 129         msg_Warn( p_input, "cannot stat() file `%s'", psz_name );
 130 #   endif
 131         return VLC_EGENERIC;
 132     }
 133 #endif
 134
 135     p_input->pf_read = Read;
 136     p_input->pf_set_program = input_SetProgram;
 137     p_input->pf_set_area = NULL;
 138     p_input->pf_seek = Seek;
 139
 140     vlc_mutex_lock( &p_input->stream.stream_lock );
 141
 142     if( *p_input->psz_access && !strncmp( p_input->psz_access, "stream", 7 ) )
 143     {
 144         /* stream:%s */
 145         p_input->stream.b_pace_control = 0;
 146         p_input->stream.b_seekable = 0;
 147         p_input->stream.p_selected_area->i_size = 0;
 148     }
 149     else if( *p_input->psz_access &&
 150              !strncmp( p_input->psz_access, "kfir", 7 ) )
 151     {
 152         /* stream:%s */
 153         p_input->stream.b_pace_control = 0;
 154         p_input->stream.b_seekable = 0;
 155         p_input->stream.p_selected_area->i_size = 0;
 156         b_kfir = 1;
 157     }
 158     else
 159     {
 160         /* file:%s or %s */
 161         p_input->stream.b_pace_control = 1;
 162
 163         if( b_stdin )
 164         {
 165             p_input->stream.b_seekable = 0;
 166             p_input->stream.p_selected_area->i_size = 0;
 167         }
 168 #ifdef UNDER_CE
 169         else if( VLC_TRUE )
 170         {
 171             /* We'll update i_size after it's been opened */
 172             p_input->stream.b_seekable = 1;
 173         }
 174 #elif defined( HAVE_SYS_STAT_H )
 175         else if( S_ISREG(stat_info.st_mode) || S_ISCHR(stat_info.st_mode)
 176                   || S_ISBLK(stat_info.st_mode) )
 177         {
 178             p_input->stream.b_seekable = 1;
 179             p_input->stream.p_selected_area->i_size = stat_info.st_size;
 180         }
 181         else if( S_ISFIFO(stat_info.st_mode)
 182 #   if !defined( SYS_BEOS ) && !defined( WIN32 )
 183                   || S_ISSOCK(stat_info.st_mode)
 184 #   endif
 185                )
 186         {
 187             p_input->stream.b_seekable = 0;
 188             p_input->stream.p_selected_area->i_size = 0;
 189         }
 190 #endif
 191         else
 192         {
 193             vlc_mutex_unlock( &p_input->stream.stream_lock );
 194             msg_Err( p_input, "unknown file type for `%s'", psz_name );
 195             return VLC_EGENERIC;
 196         }
 197     }
 198
 199     p_input->stream.p_selected_area->i_tell = 0;
 200     p_input->stream.i_method = INPUT_METHOD_FILE;
 201     vlc_mutex_unlock( &p_input->stream.stream_lock );
 202
 203     msg_Dbg( p_input, "opening file `%s'", psz_name );
 204     p_access_data = malloc( sizeof(_input_socket_t) );
 205     p_input->p_access_data = (void *)p_access_data;
 206     if( p_access_data == NULL )
 207     {
 208         msg_Err( p_input, "out of memory" );
 209         return VLC_ENOMEM;
 210     }
 211
 212     p_access_data->i_nb_reads = 0;
 213     p_access_data->b_kfir = b_kfir;
 214     if( b_stdin )
 215     {
 216         p_access_data->_socket.i_handle = 0;
 217     }
 218     else
 219     {
 220 #ifdef UNDER_CE
 221         wchar_t psz_filename[MAX_PATH];
 222         MultiByteToWideChar( CP_ACP, 0, psz_name, -1, psz_filename, MAX_PATH );
 223
 224         p_access_data->_socket.i_handle = (int)CreateFile( psz_filename,
 225             GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
 226             FILE_ATTRIBUTE_NORMAL, NULL );
 227
 228         if( (HANDLE)p_access_data->_socket.i_handle == INVALID_HANDLE_VALUE )
 229         {
 230             msg_Err( p_input, "cannot open file %s", psz_name );
 231             free( p_access_data );
 232             return VLC_EGENERIC;
 233         }
 234         p_input->stream.p_selected_area->i_size =
 235                 GetFileSize( (HANDLE)p_access_data->_socket.i_handle, NULL );
 236 #else
 237         p_access_data->_socket.i_handle = open( psz_name,
 238                                                 O_NONBLOCK /*| O_LARGEFILE*/ );
 239         if( p_access_data->_socket.i_handle == -1 )
 240         {
 241 #   ifdef HAVE_ERRNO_H
 242             msg_Err( p_input, "cannot open file %s (%s)", psz_name,
 243                               strerror(errno) );
 244 #   else
 245             msg_Err( p_input, "cannot open file %s", psz_name );
 246 #   endif
 247             free( p_access_data );
 248             return VLC_EGENERIC;
 249         }
 250 #endif
 251     }
 252
 253     if ( p_input->stream.b_seekable
 254           && !p_input->stream.p_selected_area->i_size )
 255     {
 256         msg_Err( p_input, "file %s is empty, aborting", psz_name );
 257         free( p_access_data );
 258         return VLC_EGENERIC;
 259     }
 260
 261     /* Update default_pts to a suitable value for file access */
 262     p_input->i_pts_delay = config_GetInt( p_input, "file-caching" ) * 1000;
 263
 264     return VLC_SUCCESS;
 265 }
 266
 267 /*****************************************************************************
 268  * Close: close the target
 269  *****************************************************************************/
 270 static void Close( vlc_object_t * p_this )
 271 {
 272     input_thread_t * p_input = (input_thread_t *)p_this;
 273     input_socket_t * p_access_data = (input_socket_t *)p_input->p_access_data;
 274
 275     msg_Info( p_input, "closing `%s/%s://%s'",
 276               p_input->psz_access, p_input->psz_demux, p_input->psz_name );
 277
 278 #ifdef UNDER_CE
 279     CloseHandle( (HANDLE)p_access_data->i_handle );
 280 #else
 281     close( p_access_data->i_handle );
 282 #endif
 283
 284     free( p_access_data );
 285 }
 286
 287 /*****************************************************************************
 288  * Read: standard read on a file descriptor.
 289  *****************************************************************************/
 290 static ssize_t Read( input_thread_t * p_input, byte_t * p_buffer, size_t i_len )
 291 {
 292     _input_socket_t * p_access_data = (_input_socket_t *)p_input->p_access_data;
 293     ssize_t i_ret;
 294
 295 #ifdef UNDER_CE
 296     if( !ReadFile( (HANDLE)p_access_data->_socket.i_handle, p_buffer, i_len,
 297                    (LPDWORD)&i_ret, NULL ) )
 298     {
 299         i_ret = -1;
 300     }
 301 #else
 302 #ifndef WIN32
 303     if ( !p_input->stream.b_pace_control )
 304     {
 305         if ( !p_access_data->b_kfir )
 306         {
 307             /* Find if some data is available. This won't work under Windows. */
 308             struct timeval  timeout;
 309             fd_set          fds;
 310
 311             /* Initialize file descriptor set */
 312             FD_ZERO( &fds );
 313             FD_SET( p_access_data->_socket.i_handle, &fds );
 314
 315             /* We'll wait 0.5 second if nothing happens */
 316             timeout.tv_sec = 0;
 317             timeout.tv_usec = 500000;
 318
 319             /* Find if some data is available */
 320             while( (i_ret = select( p_access_data->_socket.i_handle + 1, &fds,
 321                                     NULL, NULL, &timeout )) == 0
 322                     || (i_ret < 0 && errno == EINTR) )
 323             {
 324                 FD_ZERO( &fds );
 325                 FD_SET( p_access_data->_socket.i_handle, &fds );
 326                 timeout.tv_sec = 0;
 327                 timeout.tv_usec = 500000;
 328
 329                 if( p_input->b_die || p_input->b_error )
 330                 {
 331                     return 0;
 332                 }
 333             }
 334
 335             if( i_ret < 0 )
 336             {
 337                 msg_Err( p_input, "select error (%s)", strerror(errno) );
 338                 return -1;
 339             }
 340
 341             i_ret = read( p_access_data->_socket.i_handle, p_buffer, i_len );
 342         }
 343         else
 344         {
 345             /* b_kfir ; work around a buggy poll() driver implementation */
 346             while ( (i_ret = read( p_access_data->_socket.i_handle, p_buffer,
 347                                    i_len )) == 0 &&
 348                       !p_input->b_die && !p_input->b_error )
 349             {
 350                 msleep(INPUT_ERROR_SLEEP);
 351             }
 352         }
 353     }
 354     else
 355 #   endif
 356     {
 357         /* b_pace_control || WIN32 */
 358         i_ret = read( p_access_data->_socket.i_handle, p_buffer, i_len );
 359     }
 360 #endif
 361
 362     if( i_ret < 0 )
 363     {
 364 #ifdef HAVE_ERRNO_H
 365         if ( errno != EINTR && errno != EAGAIN )
 366             msg_Err( p_input, "read failed (%s)", strerror(errno) );
 367 #else
 368         msg_Err( p_input, "read failed" );
 369 #endif
 370
 371         /* Delay a bit to avoid consuming all the CPU. This is particularly
 372          * useful when reading from an unconnected FIFO. */
 373         msleep( INPUT_ERROR_SLEEP );
 374     }
 375
 376     p_access_data->i_nb_reads++;
 377 #ifdef HAVE_SYS_STAT_H
 378     if ( p_input->stream.p_selected_area->i_size != 0
 379             && (p_access_data->i_nb_reads % INPUT_FSTAT_NB_READS) == 0 )
 380     {
 381 #if defined( WIN32 ) && !defined( UNDER_CE )
 382         struct _stati64 stat_info;
 383 #else
 384         struct stat stat_info;
 385 #endif
 386         if ( fstat( p_access_data->_socket.i_handle, &stat_info ) == -1 )
 387         {
 388 #   ifdef HAVE_ERRNO_H
 389             msg_Warn( p_input, "couldn't stat again the file (%s)",
 390                       strerror(errno) );
 391 #   else
 392             msg_Warn( p_input, "couldn't stat again the file" );
 393 #   endif
 394         }
 395         else if ( p_input->stream.p_selected_area->i_size != stat_info.st_size )
 396         {
 397             p_input->stream.p_selected_area->i_size = stat_info.st_size;
 398             p_input->stream.b_changed = 1;
 399         }
 400     }
 401 #endif
 402
 403     return i_ret;
 404 }
 405
 406 /*****************************************************************************
 407  * Seek: seek to a specific location in a file
 408  *****************************************************************************/
 409 static void Seek( input_thread_t * p_input, off_t i_pos )
 410 {
 411 #define S p_input->stream
 412     input_socket_t * p_access_data = (input_socket_t *)p_input->p_access_data;
 413
 414 #if defined( WIN32 ) && !defined( UNDER_CE )
 415     _lseeki64( p_access_data->i_handle, i_pos, SEEK_SET );
 416 #else
 417     lseek( p_access_data->i_handle, i_pos, SEEK_SET );
 418 #endif
 419
 420     vlc_mutex_lock( &S.stream_lock );
 421     S.p_selected_area->i_tell = i_pos;
 422     if( S.p_selected_area->i_tell > S.p_selected_area->i_size )
 423     {
 424         msg_Err( p_input, "seeking too far" );
 425         S.p_selected_area->i_tell = S.p_selected_area->i_size;
 426     }
 427     else if( S.p_selected_area->i_tell < 0 )
 428     {
 429         msg_Err( p_input, "seeking too early" );
 430         S.p_selected_area->i_tell = 0;
 431     }
 432     vlc_mutex_unlock( &S.stream_lock );
 433 #undef S
 434 }
 435