git.sesse.net Git - vlc/blob - plugins/vcd/input_vcd.c

   1 /****************************************************************************
   2  * input_vcd.c: VideoCD raw reading plugin.
   3  *****************************************************************************
   4  * Copyright (C) 1998-2001 VideoLAN
   5  *
   6  * Author: Johan Bilien <jobi@via.ecp.fr>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 #include <videolan/vlc.h>
  30
  31 #ifdef HAVE_UNISTD_H
  32 #   include <unistd.h>
  33 #endif
  34
  35 #include <fcntl.h>
  36 #include <sys/types.h>
  37 #include <string.h>
  38 #include <errno.h>
  39
  40 #ifdef STRNCASECMP_IN_STRINGS_H
  41 #   include <strings.h>
  42 #endif
  43
  44 #if defined( WIN32 )
  45 #   include <io.h>                                                 /* read() */
  46 #else
  47 #   include <sys/uio.h>                                      /* struct iovec */
  48 #endif
  49
  50 #if defined( WIN32 )
  51 #   include "input_iovec.h"
  52 #endif
  53
  54 #include "stream_control.h"
  55 #include "input_ext-intf.h"
  56 #include "input_ext-dec.h"
  57 #include "input_ext-plugins.h"
  58
  59 #include "debug.h"
  60
  61 #include "input_vcd.h"
  62 #include "cdrom_tools.h"
  63
  64 /* how many blocks VCDRead will read in each loop */
  65 #define VCD_BLOCKS_ONCE 20
  66 #define VCD_DATA_ONCE   (VCD_BLOCKS_ONCE * VCD_DATA_SIZE)
  67
  68 /*****************************************************************************
  69  * Local prototypes
  70  *****************************************************************************/
  71 /* called from outside */
  72 static int  VCDInit         ( struct input_thread_s * );
  73 static void VCDEnd          ( struct input_thread_s * );
  74 static int  PSDemux        ( struct input_thread_s * );
  75 static int  VCDRewind       ( struct input_thread_s * );
  76
  77 static int  VCDOpen         ( struct input_thread_s *);
  78 static void VCDClose        ( struct input_thread_s *);
  79 static int  VCDRead         ( struct input_thread_s *, byte_t *, size_t );
  80 static void VCDSeek         ( struct input_thread_s *, off_t );
  81 static int  VCDSetArea      ( struct input_thread_s *, struct input_area_s * );
  82 static int  VCDSetProgram   ( struct input_thread_s *, pgrm_descriptor_t * );
  83
  84 static ssize_t PSRead       ( struct input_thread_s *, data_packet_t ** );
  85 /*****************************************************************************
  86  * Functions exported as capabilities. They are declared as static so that
  87  * we don't pollute the namespace too much.
  88  *****************************************************************************/
  89 void _M( access_getfunctions )( function_list_t * p_function_list )
  90 {
  91 #define access p_function_list->functions.access
  92     access.pf_open             = VCDOpen;
  93     access.pf_close            = VCDClose;
  94     access.pf_read             = VCDRead;
  95     access.pf_set_area         = VCDSetArea;
  96     access.pf_set_program      = VCDSetProgram;
  97     access.pf_seek             = VCDSeek;
  98 #undef access
  99 }
 100
 101
 102 void _M( demux_getfunctions )( function_list_t * p_function_list )
 103 {
 104 #define demux p_function_list->functions.demux
 105     demux.pf_init             = VCDInit;
 106     demux.pf_end              = VCDEnd;
 107     demux.pf_demux            = PSDemux;
 108     demux.pf_rewind           = VCDRewind;
 109 #undef demux
 110 }
 111
 112 /*
 113  * Data reading functions
 114  */
 115
 116 /*****************************************************************************
 117  * VCDOpen: open vcd
 118  *****************************************************************************/
 119 static int VCDOpen( struct input_thread_s *p_input )
 120 {
 121     char *                  psz_orig;
 122     char *                  psz_parser;
 123     char *                  psz_source;
 124     char *                  psz_next;
 125     thread_vcd_data_t *  p_vcd;
 126     int                  i;
 127     input_area_t *       p_area;
 128     int                  i_title = 1;
 129     int                  i_chapter = 1;
 130
 131     p_vcd = malloc( sizeof(thread_vcd_data_t) );
 132
 133     if( p_vcd == NULL )
 134     {
 135         intf_ErrMsg( "vcd error: out of memory" );
 136         return -1;
 137     }
 138
 139     p_input->i_mtu = VCD_DATA_ONCE;
 140     p_input->p_access_data = (void *)p_vcd;
 141
 142     /* parse the options passed in command line : */
 143     psz_orig = psz_parser = psz_source = strdup( p_input->psz_name );
 144
 145     if( !psz_orig )
 146     {
 147         return( -1 );
 148     }
 149
 150     while( *psz_parser && *psz_parser != '@' )
 151     {
 152         psz_parser++;
 153     }
 154
 155     if( *psz_parser == '@' )
 156     {
 157         /* Found options */
 158         *psz_parser = '\0';
 159         ++psz_parser;
 160
 161         i_title = (int)strtol( psz_parser, &psz_next, 10 );
 162         if( *psz_next )
 163         {
 164             psz_parser = psz_next + 1;
 165             i_chapter = (int)strtol( psz_parser, &psz_next, 10 );
 166         }
 167
 168         i_title = i_title ? i_title : 1;
 169         i_chapter = i_chapter ? i_chapter : 1;
 170     }
 171
 172     if( !*psz_source )
 173     {
 174         if( !p_input->psz_access )
 175         {
 176             free( psz_orig );
 177             return -1;
 178         }
 179         psz_source = config_GetPszVariable( INPUT_VCD_DEVICE_VAR );
 180     }
 181
 182     vlc_mutex_lock( &p_input->stream.stream_lock );
 183
 184     /* If we are here we can control the pace... */
 185     p_input->stream.b_pace_control = 1;
 186
 187     p_input->stream.b_seekable = 1;
 188     p_input->stream.p_selected_area->i_size = 0;
 189     p_input->stream.p_selected_area->i_tell = 0;
 190
 191     vlc_mutex_unlock( &p_input->stream.stream_lock );
 192
 193     p_vcd->i_handle = open( psz_source, O_RDONLY | O_NONBLOCK );
 194
 195     if( p_vcd->i_handle == -1 )
 196     {
 197         intf_ErrMsg( "input: vcd: Could not open %s\n", psz_source );
 198         free (p_vcd);
 199         return -1;
 200     }
 201
 202     /* We read the Table Of Content information */
 203     p_vcd->nb_tracks = ioctl_GetTrackCount( p_vcd->i_handle,
 204                                             psz_source );
 205     if( p_vcd->nb_tracks < 0 )
 206     {
 207         intf_ErrMsg( "input: vcd: was unable to count tracks" );
 208         free( p_vcd );
 209         return -1;
 210     }
 211     else if( p_vcd->nb_tracks <= 1 )
 212     {
 213         intf_ErrMsg( "input: vcd: no movie tracks found" );
 214         free( p_vcd );
 215         return -1;
 216     }
 217
 218     p_vcd->p_sectors = ioctl_GetSectors( p_vcd->i_handle,
 219                                          psz_source );
 220     if ( p_vcd->p_sectors == NULL )
 221     {
 222         input_BuffersEnd( p_input->p_method_data );
 223         free( p_vcd );
 224         return -1;
 225     }
 226
 227     /* Set stream and area data */
 228     vlc_mutex_lock( &p_input->stream.stream_lock );
 229
 230     /* Initialize ES structures */
 231     input_InitStream( p_input, sizeof( stream_ps_data_t ) );
 232
 233     /* disc input method */
 234     p_input->stream.i_method = INPUT_METHOD_VCD;
 235
 236 #define area p_input->stream.pp_areas
 237     for( i = 1 ; i <= p_vcd->nb_tracks - 1 ; i++ )
 238     {
 239         input_AddArea( p_input );
 240
 241         /* Titles are Program Chains */
 242         area[i]->i_id = i;
 243
 244         /* Absolute start offset and size */
 245         area[i]->i_start = (off_t)p_vcd->p_sectors[i] * (off_t)VCD_DATA_SIZE;
 246         area[i]->i_size = (off_t)(p_vcd->p_sectors[i+1] - p_vcd->p_sectors[i])
 247                            * (off_t)VCD_DATA_SIZE;
 248
 249         /* Number of chapters */
 250         area[i]->i_part_nb = 0;   // will be the entry points
 251         area[i]->i_part = 1;
 252
 253         area[i]->i_plugin_data = p_vcd->p_sectors[i];
 254     }
 255 #undef area
 256
 257     p_area = p_input->stream.pp_areas[i_title];
 258
 259     VCDSetArea( p_input, p_area );
 260
 261     vlc_mutex_unlock( &p_input->stream.stream_lock );
 262
 263     p_input->psz_demux = "vcd";
 264
 265     return 0;
 266 }
 267
 268
 269
 270 /*****************************************************************************
 271  * VCDClose: closes vcd
 272  *****************************************************************************/
 273 static void VCDClose( struct input_thread_s *p_input )
 274 {
 275     thread_vcd_data_t *     p_vcd
 276         = (thread_vcd_data_t *)p_input->p_access_data;
 277     close( p_vcd->i_handle );
 278     free( p_vcd );
 279 }
 280
 281 /*****************************************************************************
 282  * VCDRead: reads from the VCD into PES packets.
 283  *****************************************************************************
 284  * Returns -1 in case of error, 0 in case of EOF, otherwise the number of
 285  * bytes.
 286  *****************************************************************************/
 287 static int VCDRead( input_thread_t * p_input, byte_t * p_buffer,
 288                      size_t i_len )
 289 {
 290     thread_vcd_data_t *     p_vcd;
 291     int                     i_blocks;
 292     int                     i_index;
 293     int                     i_read;
 294     byte_t                  p_last_sector[ VCD_DATA_SIZE ];
 295
 296     p_vcd = (thread_vcd_data_t *)p_input->p_access_data;
 297
 298     i_read = 0;
 299
 300     /* Compute the number of blocks we have to read */
 301
 302     i_blocks = i_len / VCD_DATA_SIZE;
 303
 304     for ( i_index = 0 ; i_index < i_blocks ; i_index++ )
 305     {
 306         if ( ioctl_ReadSector( p_vcd->i_handle, p_vcd->i_sector,
 307                     p_buffer + i_index * VCD_DATA_SIZE ) < 0 )
 308         {
 309             intf_ErrMsg( "input: vcd: could not read sector %d\n",
 310                     p_vcd->i_sector );
 311             return -1;
 312         }
 313
 314         p_vcd->i_sector ++;
 315         if ( p_vcd->i_sector == p_vcd->p_sectors[p_vcd->i_track + 1] )
 316         {
 317             /* FIXME we should go to next track */
 318             return 0;
 319         }
 320         i_read += VCD_DATA_SIZE;
 321     }
 322
 323     if ( i_len % VCD_DATA_SIZE ) /* this should not happen */
 324     {
 325         if ( ioctl_ReadSector( p_vcd->i_handle, p_vcd->i_sector,
 326                     p_last_sector ) < 0 )
 327         {
 328             intf_ErrMsg( "input: vcd: could not read sector %d\n",
 329                     p_vcd->i_sector );
 330             return -1;
 331         }
 332
 333         FAST_MEMCPY( p_buffer + i_blocks * VCD_DATA_SIZE,
 334                     p_last_sector, i_len % VCD_DATA_SIZE );
 335         i_read += i_len % VCD_DATA_SIZE;
 336     }
 337
 338     p_input->stream.p_selected_area->i_tell =
 339         (off_t)p_vcd->i_sector * (off_t)VCD_DATA_SIZE
 340          - p_input->stream.p_selected_area->i_start;
 341
 342     return i_read;
 343 }
 344
 345
 346 /*****************************************************************************
 347  * VCDSetProgram: Does nothing since a VCD is mono_program
 348  *****************************************************************************/
 349 static int VCDSetProgram( input_thread_t * p_input,
 350                           pgrm_descriptor_t * p_program)
 351 {
 352     return 0;
 353 }
 354
 355
 356 /*****************************************************************************
 357  * VCDSetArea: initialize input data for title x, chapter y.
 358  * It should be called for each user navigation request.
 359  ****************************************************************************/
 360 static int VCDSetArea( input_thread_t * p_input, input_area_t * p_area )
 361 {
 362     thread_vcd_data_t *     p_vcd;
 363
 364     p_vcd = (thread_vcd_data_t*)p_input->p_access_data;
 365
 366     /* we can't use the interface slider until initilization is complete */
 367     p_input->stream.b_seekable = 0;
 368
 369     if( p_area != p_input->stream.p_selected_area )
 370     {
 371         /* Reset the Chapter position of the current title */
 372         p_input->stream.p_selected_area->i_part = 1;
 373         p_input->stream.p_selected_area->i_tell = 0;
 374
 375         /* Change the default area */
 376         p_input->stream.p_selected_area = p_area;
 377
 378         /* Change the current track */
 379         /* The first track is not a valid one  */
 380         p_vcd->i_track = p_area->i_id;
 381         p_vcd->i_sector = p_vcd->p_sectors[p_vcd->i_track];
 382     }
 383
 384     /* warn interface that something has changed */
 385     p_input->stream.b_seekable = 1;
 386     p_input->stream.b_changed = 1;
 387
 388     return 0;
 389 }
 390
 391
 392 /*****************************************************************************
 393  * VCDRewind : reads a stream backward
 394  *****************************************************************************/
 395 static int VCDRewind( input_thread_t * p_input )
 396 {
 397     return( -1 );
 398 }
 399
 400 /****************************************************************************
 401  * VCDSeek
 402  ****************************************************************************/
 403 static void VCDSeek( input_thread_t * p_input, off_t i_off )
 404 {
 405     thread_vcd_data_t *               p_vcd;
 406
 407     p_vcd = (thread_vcd_data_t *) p_input->p_access_data;
 408
 409     p_vcd->i_sector = p_vcd->p_sectors[p_vcd->i_track]
 410                        + i_off / (off_t)VCD_DATA_SIZE;
 411
 412     p_input->stream.p_selected_area->i_tell =
 413         (off_t)p_vcd->i_sector * (off_t)VCD_DATA_SIZE
 414          - p_input->stream.p_selected_area->i_start;
 415 }
 416
 417 /*
 418  * Demux functions
 419  */
 420
 421
 422 /*****************************************************************************
 423  * VCDInit: initializes VCD structures
 424  *****************************************************************************/
 425 static int VCDInit( input_thread_t * p_input )
 426 {
 427     es_descriptor_t *       p_es;
 428
 429     vlc_mutex_lock( &p_input->stream.stream_lock );
 430
 431     /* Set program information. */
 432     input_AddProgram( p_input, 0, sizeof( stream_ps_data_t ) );
 433     p_input->stream.p_selected_program = p_input->stream.pp_programs[0];
 434
 435     /* No PSM to read in disc mode, we already have all the information */
 436     p_input->stream.p_selected_program->b_is_ok = 1;
 437
 438     p_es = input_AddES( p_input, p_input->stream.p_selected_program, 0xe0, 0 );
 439     p_es->i_stream_id = 0xe0;
 440     p_es->i_type = MPEG1_VIDEO_ES;
 441     p_es->i_cat = VIDEO_ES;
 442
 443     if( p_main->b_video )
 444     {
 445         input_SelectES( p_input, p_es );
 446     }
 447
 448     p_es = input_AddES( p_input, p_input->stream.p_selected_program, 0xc0, 0 );
 449     p_es->i_stream_id = 0xc0;
 450     p_es->i_type = MPEG1_AUDIO_ES;
 451     p_es->b_audio = 1;
 452     p_es->i_cat = AUDIO_ES;
 453
 454     if( p_main->b_audio )
 455     {
 456         input_SelectES( p_input, p_es );
 457     }
 458
 459     vlc_mutex_unlock( &p_input->stream.stream_lock );
 460
 461     return 0;
 462 }
 463
 464 /*****************************************************************************
 465  * VCDEnd: frees unused data
 466  *****************************************************************************/
 467 static void VCDEnd( input_thread_t * p_input )
 468 {
 469     thread_vcd_data_t *     p_vcd;
 470
 471     input_BuffersEnd( p_input->p_method_data );
 472
 473     p_vcd = (thread_vcd_data_t*)p_input->p_access_data;
 474
 475     free( p_vcd );
 476 }
 477
 478
 479 /*****************************************************************************
 480  * PSDemux: reads and demuxes data packets
 481  *****************************************************************************
 482  * Returns -1 in case of error, 0 in case of EOF, otherwise the number of
 483  * packets.
 484  *****************************************************************************/
 485 static int PSDemux( input_thread_t * p_input )
 486 {
 487     int                 i;
 488
 489     for( i = 0; i < VCD_BLOCKS_ONCE; i++ )
 490     {
 491         data_packet_t *     p_data;
 492         ssize_t             i_result;
 493
 494         i_result = input_ReadPS( p_input, &p_data );
 495
 496         if( i_result <= 0 )
 497         {
 498             return( i_result );
 499         }
 500
 501         input_DemuxPS( p_input, p_data );
 502     }
 503
 504     return( i );
 505 }
 506