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-2004 VideoLAN
   5  * $Id$
   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 #include <errno.h>
  33 #ifdef HAVE_SYS_TYPES_H
  34 #   include <sys/types.h>
  35 #endif
  36 #ifdef HAVE_SYS_TIME_H
  37 #   include <sys/time.h>
  38 #endif
  39 #ifdef HAVE_SYS_STAT_H
  40 #   include <sys/stat.h>
  41 #endif
  42 #ifdef HAVE_FCNTL_H
  43 #   include <fcntl.h>
  44 #endif
  45
  46 #ifdef HAVE_UNISTD_H
  47 #   include <unistd.h>
  48 #elif defined( WIN32 ) && !defined( UNDER_CE )
  49 #   include <io.h>
  50 #endif
  51
  52 #if defined( WIN32 ) && !defined( UNDER_CE )
  53 /* stat() support for large files on win32 */
  54 #   define stat _stati64
  55 #   define fstat(a,b) _fstati64(a,b)
  56 #   ifdef lseek
  57 #      undef lseek
  58 #   endif
  59 #   define lseek _lseeki64
  60 #elif defined( UNDER_CE )
  61 #   ifdef read
  62 #      undef read
  63 #   endif
  64 #   define read(a,b,c) fread(b,1,c,a)
  65 #   define close(a) fclose(a)
  66 #   ifdef lseek
  67 #      undef lseek
  68 #   endif
  69 #   define lseek fseek
  70 #endif
  71
  72 /*****************************************************************************
  73  * Module descriptor
  74  *****************************************************************************/
  75 static int  Open ( vlc_object_t * );
  76 static void Close( vlc_object_t * );
  77
  78 #define CACHING_TEXT N_("Caching value in ms")
  79 #define CACHING_LONGTEXT N_( \
  80     "Allows you to modify the default caching value for file streams. This " \
  81     "value should be set in millisecond units." )
  82 #define CAT_TEXT N_("Concatenate with additional files")
  83 #define CAT_LONGTEXT N_( \
  84     "Allows you to play split files as if they were part of a unique file. " \
  85     "Specify a comma-separated list of files." )
  86
  87 vlc_module_begin();
  88     set_description( _("Standard filesystem file input") );
  89     set_name( _("File") );
  90     set_category( CAT_INPUT );
  91     set_subcategory( SUBCAT_INPUT_ACCESS );
  92     add_integer( "file-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
  93     add_string( "file-cat", NULL, NULL, CAT_TEXT, CAT_LONGTEXT, VLC_TRUE );
  94     set_capability( "access2", 50 );
  95     add_shortcut( "file" );
  96     add_shortcut( "stream" );
  97     add_shortcut( "kfir" );
  98     set_callbacks( Open, Close );
  99 vlc_module_end();
 100
 101
 102 /*****************************************************************************
 103  * Exported prototypes
 104  *****************************************************************************/
 105 static int  Seek( access_t *, int64_t );
 106 static int  Read( access_t *, uint8_t *, int );
 107 static int  Control( access_t *, int, va_list );
 108
 109 static int  _OpenFile( access_t *, char * );
 110
 111 typedef struct
 112 {
 113     char     *psz_name;
 114     int64_t  i_size;
 115
 116 } file_entry_t;
 117
 118 struct access_sys_t
 119 {
 120     unsigned int i_nb_reads;
 121     vlc_bool_t   b_kfir;
 122
 123     /* Files list */
 124     int          i_file;
 125     file_entry_t **file;
 126
 127     /* Current file */
 128     int  i_index;
 129 #ifndef UNDER_CE
 130     int  fd;
 131     int  fd_backup;
 132 #else
 133     FILE *fd;
 134     FILE *fd_backup;
 135 #endif
 136
 137     /* */
 138     vlc_bool_t b_seekable;
 139     vlc_bool_t b_pace_control;
 140 };
 141
 142 /*****************************************************************************
 143  * Open: open the file
 144  *****************************************************************************/
 145 static int Open( vlc_object_t *p_this )
 146 {
 147     access_t     *p_access = (access_t*)p_this;
 148     access_sys_t *p_sys;
 149     char *psz_name = p_access->psz_path;
 150     char *psz;
 151
 152 #ifdef HAVE_SYS_STAT_H
 153     int                 i_stat;
 154     struct stat         stat_info;
 155 #endif
 156     vlc_bool_t          b_stdin;
 157
 158     file_entry_t *      p_file;
 159
 160
 161     b_stdin = psz_name[0] == '-' && psz_name[1] == '\0';
 162
 163 #ifdef HAVE_SYS_STAT_H
 164     if( !b_stdin && (i_stat = stat( psz_name, &stat_info )) == (-1) )
 165     {
 166         msg_Warn( p_access, "cannot stat() file `%s' (%s)",
 167                   psz_name, strerror(errno));
 168         return VLC_EGENERIC;
 169     }
 170 #endif
 171
 172     p_access->pf_read = Read;
 173     p_access->pf_block = NULL;
 174     p_access->pf_seek = Seek;
 175     p_access->pf_control = Control;
 176     p_access->info.i_update = 0;
 177     p_access->info.i_size = 0;
 178     p_access->info.i_pos = 0;
 179     p_access->info.b_eof = VLC_FALSE;
 180     p_access->info.i_title = 0;
 181     p_access->info.i_seekpoint = 0;
 182     p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
 183     p_sys->i_nb_reads = 0;
 184     p_sys->b_kfir = VLC_FALSE;
 185     p_sys->file = NULL;
 186     p_sys->i_file = 0;
 187     p_sys->i_index = 0;
 188     p_sys->fd = -1;
 189
 190     if( !strcasecmp( p_access->psz_access, "stream" ) )
 191     {
 192         p_sys->b_seekable = VLC_FALSE;
 193         p_sys->b_pace_control = VLC_FALSE;
 194     }
 195     else if( !strcasecmp( p_access->psz_access, "kfir" ) )
 196     {
 197         p_sys->b_seekable = VLC_FALSE;
 198         p_sys->b_pace_control = VLC_FALSE;
 199         p_sys->b_kfir = VLC_TRUE;
 200     }
 201     else
 202     {
 203         /* file:%s or %s */
 204         p_sys->b_pace_control = VLC_TRUE;
 205
 206         if( b_stdin )
 207         {
 208             p_sys->b_seekable = VLC_FALSE;
 209         }
 210 #ifdef UNDER_CE
 211         else if( VLC_TRUE )
 212         {
 213             /* We'll update i_size after it's been opened */
 214             p_sys->b_seekable = VLC_TRUE;
 215         }
 216 #elif defined( HAVE_SYS_STAT_H )
 217         else if( S_ISREG(stat_info.st_mode) || S_ISCHR(stat_info.st_mode) ||
 218                  S_ISBLK(stat_info.st_mode) )
 219         {
 220             p_sys->b_seekable = VLC_TRUE;
 221             p_access->info.i_size = stat_info.st_size;
 222         }
 223         else if( S_ISFIFO(stat_info.st_mode)
 224 #   if !defined( SYS_BEOS ) && !defined( WIN32 )
 225                   || S_ISSOCK(stat_info.st_mode)
 226 #   endif
 227                )
 228         {
 229             p_sys->b_seekable = VLC_FALSE;
 230         }
 231 #endif
 232         else
 233         {
 234             msg_Err( p_access, "unknown file type for `%s'", psz_name );
 235             return VLC_EGENERIC;
 236         }
 237     }
 238
 239     msg_Dbg( p_access, "opening file `%s'", psz_name );
 240
 241     if( b_stdin )
 242     {
 243         p_sys->fd = 0;
 244     }
 245     else if( _OpenFile( p_access, psz_name ) )
 246     {
 247         free( p_sys );
 248         return VLC_EGENERIC;
 249     }
 250
 251     if( p_sys->b_seekable && !p_access->info.i_size )
 252     {
 253         /* FIXME that's bad because all others access will be probed */
 254         msg_Err( p_access, "file %s is empty, aborting", psz_name );
 255         free( p_sys );
 256         return VLC_EGENERIC;
 257     }
 258
 259     /* Update default_pts to a suitable value for file access */
 260     var_Create( p_access, "file-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 261
 262     /*
 263      * Get the additional list of files
 264      */
 265     p_file = malloc( sizeof(file_entry_t) );
 266     p_file->i_size = p_access->info.i_size;
 267     p_file->psz_name = strdup( psz_name );
 268     TAB_APPEND( p_sys->i_file, p_sys->file, p_file );
 269
 270     psz = var_CreateGetString( p_access, "file-cat" );
 271     if( *psz )
 272     {
 273         char *psz_parser = psz_name = psz;
 274         int64_t i_size;
 275
 276         while( psz_name && *psz_name )
 277         {
 278             psz_parser = strchr( psz_name, ',' );
 279             if( psz_parser ) *psz_parser = 0;
 280
 281             psz_name = strdup( psz_name );
 282             if( psz_name )
 283             {
 284                 msg_Dbg( p_access, "adding file `%s'", psz_name );
 285                 i_size = 0;
 286
 287 #ifdef HAVE_SYS_STAT_H
 288                 if( !stat( psz_name, &stat_info ) )
 289                 {
 290                     p_access->info.i_size += stat_info.st_size;
 291                     i_size = stat_info.st_size;
 292                 }
 293                 else
 294                 {
 295                     msg_Dbg( p_access, "cannot stat() file `%s'", psz_name );
 296                 }
 297 #endif
 298                 p_file = malloc( sizeof(file_entry_t) );
 299                 p_file->i_size = i_size;
 300                 p_file->psz_name = psz_name;
 301
 302                 TAB_APPEND( p_sys->i_file, p_sys->file, p_file );
 303             }
 304
 305             psz_name = psz_parser;
 306             if( psz_name ) psz_name++;
 307         }
 308     }
 309     free( psz );
 310
 311     return VLC_SUCCESS;
 312 }
 313
 314 /*****************************************************************************
 315  * Close: close the target
 316  *****************************************************************************/
 317 static void Close( vlc_object_t * p_this )
 318 {
 319     access_t     *p_access = (access_t*)p_this;
 320     access_sys_t *p_sys = p_access->p_sys;
 321     int i;
 322
 323     close( p_sys->fd );
 324
 325     for( i = 0; i < p_sys->i_file; i++ )
 326     {
 327         free( p_sys->file[i]->psz_name );
 328         free( p_sys->file[i] );
 329     }
 330     free( p_sys->file );
 331
 332     free( p_sys );
 333 }
 334
 335 /*****************************************************************************
 336  * Read: standard read on a file descriptor.
 337  *****************************************************************************/
 338 static int Read( access_t *p_access, uint8_t *p_buffer, int i_len )
 339 {
 340     access_sys_t *p_sys = p_access->p_sys;
 341     int i_ret;
 342
 343 #if !defined(WIN32) && !defined(UNDER_CE)
 344     if( !p_sys->b_pace_control )
 345     {
 346         if( !p_sys->b_kfir )
 347         {
 348             /* Find if some data is available. This won't work under Windows. */
 349             struct timeval  timeout;
 350             fd_set          fds;
 351
 352             /* Initialize file descriptor set */
 353             FD_ZERO( &fds );
 354             FD_SET( p_sys->fd, &fds );
 355
 356             /* We'll wait 0.5 second if nothing happens */
 357             timeout.tv_sec = 0;
 358             timeout.tv_usec = 500000;
 359
 360             /* Find if some data is available */
 361             while( (i_ret = select( p_sys->fd + 1, &fds, NULL, NULL, &timeout )) == 0
 362                     || (i_ret < 0 && errno == EINTR) )
 363             {
 364                 FD_ZERO( &fds );
 365                 FD_SET( p_sys->fd, &fds );
 366                 timeout.tv_sec = 0;
 367                 timeout.tv_usec = 500000;
 368
 369                 if( p_access->b_die )
 370                     return 0;
 371             }
 372
 373             if( i_ret < 0 )
 374             {
 375                 msg_Err( p_access, "select error (%s)", strerror(errno) );
 376                 return -1;
 377             }
 378
 379             i_ret = read( p_sys->fd, p_buffer, i_len );
 380         }
 381         else
 382         {
 383             /* b_kfir ; work around a buggy poll() driver implementation */
 384             while ( (i_ret = read( p_sys->fd, p_buffer, i_len )) == 0 &&
 385                     !p_access->b_die )
 386             {
 387                 msleep( INPUT_ERROR_SLEEP );
 388             }
 389         }
 390     }
 391     else
 392 #endif /* WIN32 || UNDER_CE */
 393     {
 394         /* b_pace_control || WIN32 */
 395         i_ret = read( p_sys->fd, p_buffer, i_len );
 396     }
 397
 398     if( i_ret < 0 )
 399     {
 400         if( errno != EINTR && errno != EAGAIN )
 401             msg_Err( p_access, "read failed (%s)", strerror(errno) );
 402
 403         /* Delay a bit to avoid consuming all the CPU. This is particularly
 404          * useful when reading from an unconnected FIFO. */
 405         msleep( INPUT_ERROR_SLEEP );
 406     }
 407
 408     p_sys->i_nb_reads++;
 409 #ifdef HAVE_SYS_STAT_H
 410     if( p_access->info.i_size != 0 &&
 411         (p_sys->i_nb_reads % INPUT_FSTAT_NB_READS) == 0 )
 412     {
 413         struct stat stat_info;
 414         int i_file = p_sys->i_index;
 415
 416         if ( fstat( p_sys->fd, &stat_info ) == -1 )
 417         {
 418             msg_Warn( p_access, "couldn't stat again the file (%s)", strerror(errno) );
 419         }
 420         else if ( p_sys->file[i_file]->i_size != stat_info.st_size )
 421         {
 422             p_access->info.i_size += (stat_info.st_size - p_sys->file[i_file]->i_size );
 423             p_access->info.i_update |= INPUT_UPDATE_SIZE;
 424         }
 425     }
 426 #endif
 427
 428     /* If we reached an EOF then switch to the next file in the list */
 429     if ( i_ret == 0 && p_sys->i_index + 1 < p_sys->i_file )
 430     {
 431         char *psz_name = p_sys->file[++p_sys->i_index]->psz_name;
 432         p_sys->fd_backup = p_sys->fd;
 433
 434         msg_Dbg( p_access, "opening file `%s'", psz_name );
 435
 436         if ( _OpenFile( p_access, psz_name ) )
 437         {
 438             p_sys->fd = p_sys->fd_backup;
 439             return 0;
 440         }
 441
 442         close( p_sys->fd_backup );
 443
 444         /* We have to read some data */
 445         return Read( p_access, p_buffer, i_len );
 446     }
 447
 448     if( i_ret > 0 )
 449         p_access->info.i_pos += i_ret;
 450     else if( i_ret == 0 )
 451         p_access->info.b_eof = VLC_TRUE;
 452
 453     return i_ret;
 454 }
 455
 456 /*****************************************************************************
 457  * Seek: seek to a specific location in a file
 458  *****************************************************************************/
 459 static int Seek( access_t *p_access, int64_t i_pos )
 460 {
 461     access_sys_t *p_sys = p_access->p_sys;
 462     int64_t i_size = 0;
 463
 464     /* Check which file we need to access */
 465     if( p_sys->i_file > 1 )
 466     {
 467         int i;
 468         char *psz_name;
 469         p_sys->fd_backup = p_sys->fd;
 470
 471         for( i = 0; i < p_sys->i_file - 1; i++ )
 472         {
 473             if( i_pos < p_sys->file[i]->i_size + i_size )
 474                 break;
 475             i_size += p_sys->file[i]->i_size;
 476         }
 477         psz_name = p_sys->file[i]->psz_name;
 478
 479         msg_Dbg( p_access, "opening file `%s'", psz_name );
 480
 481         if ( i != p_sys->i_index && !_OpenFile( p_access, psz_name ) )
 482         {
 483             /* Close old file */
 484             close( p_sys->fd_backup );
 485             p_sys->i_index = i;
 486         }
 487         else
 488         {
 489             p_sys->fd = p_sys->fd_backup;
 490         }
 491     }
 492
 493     lseek( p_sys->fd, i_pos - i_size, SEEK_SET );
 494
 495     p_access->info.i_pos = i_pos;
 496     if( p_access->info.i_size < p_access->info.i_pos )
 497     {
 498         msg_Err( p_access, "seeking too far" );
 499         p_access->info.i_pos = p_access->info.i_size;
 500     }
 501     else if( p_access->info.i_pos < 0 )
 502     {
 503         msg_Err( p_access, "seeking too early" );
 504         p_access->info.i_pos = 0;
 505     }
 506     /* Reset eof */
 507     p_access->info.b_eof = VLC_FALSE;
 508
 509     /* FIXME */
 510     return VLC_SUCCESS;
 511 }
 512
 513 /*****************************************************************************
 514  * Control:
 515  *****************************************************************************/
 516 static int Control( access_t *p_access, int i_query, va_list args )
 517 {
 518     access_sys_t *p_sys = p_access->p_sys;
 519     vlc_bool_t   *pb_bool;
 520     int          *pi_int;
 521     int64_t      *pi_64;
 522
 523     switch( i_query )
 524     {
 525         /* */
 526         case ACCESS_CAN_SEEK:
 527         case ACCESS_CAN_FASTSEEK:
 528             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
 529             *pb_bool = p_sys->b_seekable;
 530             break;
 531
 532         case ACCESS_CAN_PAUSE:
 533         case ACCESS_CAN_CONTROL_PACE:
 534             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
 535             *pb_bool = p_sys->b_pace_control;
 536             break;
 537
 538         /* */
 539         case ACCESS_GET_MTU:
 540             pi_int = (int*)va_arg( args, int * );
 541             *pi_int = 0;
 542             break;
 543
 544         case ACCESS_GET_PTS_DELAY:
 545             pi_64 = (int64_t*)va_arg( args, int64_t * );
 546             *pi_64 = var_GetInteger( p_access, "file-caching" ) * I64C(1000);
 547             break;
 548
 549         /* */
 550         case ACCESS_SET_PAUSE_STATE:
 551             /* Nothing to do */
 552             break;
 553
 554         case ACCESS_GET_TITLE_INFO:
 555         case ACCESS_SET_TITLE:
 556         case ACCESS_SET_SEEKPOINT:
 557         case ACCESS_SET_PRIVATE_ID_STATE:
 558             return VLC_EGENERIC;
 559
 560         default:
 561             msg_Warn( p_access, "unimplemented query in control" );
 562             return VLC_EGENERIC;
 563
 564     }
 565     return VLC_SUCCESS;
 566 }
 567
 568
 569 /*****************************************************************************
 570  * OpenFile: Opens a specific file
 571  *****************************************************************************/
 572 static int _OpenFile( access_t * p_access, char * psz_name )
 573 {
 574     access_sys_t *p_sys = p_access->p_sys;
 575
 576 #ifdef UNDER_CE
 577     p_sys->fd = fopen( psz_name, "rb" );
 578     if ( !p_sys->fd )
 579     {
 580         msg_Err( p_access, "cannot open file %s" );
 581         return VLC_EGENERIC;
 582     }
 583
 584     fseek( p_sys->fd, 0, SEEK_END );
 585     p_access->info.i_size = ftell( p_sys->fd );
 586     p_access->info.i_update |= INPUT_UPDATE_SIZE;
 587     fseek( p_sys->fd, 0, SEEK_SET );
 588 #else
 589
 590     p_sys->fd = open( psz_name, O_NONBLOCK /*| O_LARGEFILE*/ );
 591     if ( p_sys->fd == -1 )
 592     {
 593         msg_Err( p_access, "cannot open file %s (%s)", psz_name,
 594                  strerror(errno) );
 595         return VLC_EGENERIC;
 596     }
 597 #endif
 598
 599     return VLC_SUCCESS;
 600 }