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

   1 /*****************************************************************************
   2  * access.c : CD digital audio input module for vlc using libcdio
   3  *****************************************************************************
   4  * Copyright (C) 2000, 2003, 2004 VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Rocky Bernstein <rocky@panix.com>
   8  *          Laurent Aimar <fenrir@via.ecp.fr>
   9  *          Gildas Bazin <gbazin@netcourrier.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #include "callback.h"      /* FIXME - reorganize callback.h, cdda.h better */
  30 #include "cdda.h"          /* private structures. Also #includes vlc things */
  31 #include "info.h"          /* headers for meta info retrieval */
  32 #include <vlc_playlist.h>  /* Has to come *after* cdda.h */
  33 #include "vlc_keys.h"
  34
  35 #include <cdio/cdio.h>
  36 #include <cdio/logging.h>
  37 #include <cdio/cd_types.h>
  38
  39 #include <stdio.h>
  40
  41 /* #ifdef variables below are defined via config.h via #include vlc above. */
  42 #ifdef HAVE_STDLIB_H
  43 #include <stdlib.h>
  44 #endif
  45
  46 #ifdef HAVE_SYS_TYPES_H
  47 #include <sys/types.h>
  48 #endif
  49
  50 #ifdef HAVE_STRING_H
  51 #include <string.h>
  52 #endif
  53
  54 #ifdef HAVE_UNISTD_H
  55 #   include <unistd.h>
  56 #endif
  57
  58 /* FIXME: This variable is a hack. Would be nice to eliminate. */
  59 access_t *p_cdda_input = NULL;
  60
  61 /*****************************************************************************
  62  * Local prototypes
  63  *****************************************************************************/
  64 static block_t *CDDAReadBlocks( access_t * p_access );
  65 static int      CDDASeek( access_t * p_access, int64_t i_pos );
  66 static int      CDDAControl( access_t *p_access, int i_query,
  67                              va_list args );
  68
  69 static int      CDDAInit( access_t *p_access, cdda_data_t *p_cdda ) ;
  70
  71
  72 /****************************************************************************
  73  * Private functions
  74  ****************************************************************************/
  75
  76 /* process messages that originate from libcdio. */
  77 static void
  78 cdio_log_handler (cdio_log_level_t level, const char message[])
  79 {
  80   cdda_data_t *p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
  81
  82   if( p_cdda == NULL )
  83       return;
  84
  85   switch (level) {
  86   case CDIO_LOG_DEBUG:
  87   case CDIO_LOG_INFO:
  88     if (p_cdda->i_debug & INPUT_DBG_CDIO)
  89       msg_Dbg( p_cdda_input, message);
  90     break;
  91   case CDIO_LOG_WARN:
  92     msg_Warn( p_cdda_input, message);
  93     break;
  94   case CDIO_LOG_ERROR:
  95   case CDIO_LOG_ASSERT:
  96     msg_Err( p_cdda_input, message);
  97     break;
  98   default:
  99     msg_Warn( p_cdda_input, message,
 100             "The above message had unknown cdio log level",
 101             level);
 102   }
 103   return;
 104 }
 105
 106
 107 #ifdef HAVE_LIBCDDB
 108 /*! This routine is called by libcddb routines on error.
 109    Setup is done by init_input_plugin.
 110 */
 111 static void
 112 cddb_log_handler (cddb_log_level_t level, const char message[])
 113 {
 114     cdda_data_t *p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
 115     switch (level)
 116     {
 117         case CDDB_LOG_DEBUG:
 118         case CDDB_LOG_INFO:
 119         if (!(p_cdda->i_debug & INPUT_DBG_CDDB)) return;
 120
 121         /* Fall through if to warn case */
 122         default:
 123             cdio_log_handler (level, message);
 124     }
 125 }
 126 #endif /*HAVE_LIBCDDB*/
 127
 128
 129 /*! This routine is when xine is not fully set up (before full initialization)
 130    or is not around (before finalization).
 131 */
 132 static void
 133 uninit_log_handler (cdio_log_level_t level, const char message[])
 134 {
 135     cdda_data_t *p_cdda = NULL;
 136
 137     if (p_cdda_input)
 138         p_cdda = (cdda_data_t *)p_cdda_input->p_sys;
 139
 140      switch (level)
 141      {
 142         case CDIO_LOG_DEBUG:
 143         case CDIO_LOG_INFO:
 144         if (!p_cdda || !(p_cdda->i_debug & (INPUT_DBG_CDIO|INPUT_DBG_CDDB)))
 145             return;
 146
 147         /* Fall through if to warn case */
 148         case CDIO_LOG_WARN:
 149             fprintf(stderr, "WARN: %s\n", message);
 150             break;
 151         case CDIO_LOG_ERROR:
 152             fprintf(stderr, "ERROR: %s\n", message);
 153             break;
 154         case CDIO_LOG_ASSERT:
 155             fprintf(stderr, "ASSERT ERROR: %s\n", message);
 156             break;
 157         default:
 158             fprintf(stderr, "UNKNOWN ERROR: %s\n%s %d\n", message,
 159                             "The above message had unknown cdio log level",
 160                             level);
 161     }
 162
 163     /* gl_default_cdio_log_handler (level, message); */
 164 }
 165
 166 /*****************************************************************************
 167  * CDDAReadBlocks: reads a group of blocks from the CD-DA and returns
 168  * an allocated pointer to the data. NULL is returned if no data
 169  * read. It is also possible if we haven't read a RIFF header in which
 170  * case one that we creaded during Open/Initialization is returned.
 171  *****************************************************************************/
 172 static block_t * CDDAReadBlocks( access_t * p_access )
 173 {
 174     block_t     *p_block;
 175     cdda_data_t *p_cdda   = (cdda_data_t *) p_access->p_sys;
 176     int          i_blocks = p_cdda->i_blocks_per_read;
 177
 178     dbg_print((INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_LSN), "called %d",
 179               p_cdda->i_lsn);
 180
 181     /* Check end of file */
 182     if( p_access->info.b_eof ) return NULL;
 183
 184     if( !p_cdda->b_header )
 185       {
 186         /* Return only the dummy RIFF header we created in Open/Init */
 187         p_block = block_New( p_access, sizeof( WAVEHEADER ) );
 188         memcpy( p_block->p_buffer, &p_cdda->waveheader, sizeof(WAVEHEADER) );
 189         p_cdda->b_header = VLC_TRUE;
 190         return p_block;
 191     }
 192
 193     /* Check end of track */
 194     while( p_cdda->i_lsn >= cdio_get_track_lsn(p_cdda->p_cdio,
 195                                                p_cdda->i_track+1) )
 196     {
 197         if( p_cdda->i_track >= p_cdda->i_first_track + p_cdda->i_titles - 1 )
 198         {
 199             p_access->info.b_eof = VLC_TRUE;
 200             return NULL;
 201         }
 202
 203         p_access->info.i_update |= INPUT_UPDATE_TITLE | INPUT_UPDATE_SIZE;
 204         p_access->info.i_title++;
 205         p_access->info.i_size =
 206                   p_cdda->p_title[p_access->info.i_title]->i_size;
 207         p_access->info.i_pos = 0;
 208         p_cdda->i_track++;
 209     }
 210
 211     /* Possibly adjust i_blocks so we don't read past the end of a track. */
 212     if( p_cdda->i_lsn + i_blocks >=
 213         cdio_get_track_lsn(p_cdda->p_cdio, p_cdda->i_track+1) )
 214     {
 215       i_blocks = cdio_get_track_lsn( p_cdda->p_cdio, p_cdda->i_track+1 )
 216         - p_cdda->i_lsn;
 217     }
 218
 219     /* Do the actual reading */
 220     p_block = block_New( p_access, i_blocks * CDIO_CD_FRAMESIZE_RAW );
 221     if( !p_block)
 222     {
 223       msg_Err( p_access, "Cannot get a new block of size: %i",
 224                i_blocks * CDIO_CD_FRAMESIZE_RAW );
 225       return NULL;
 226     }
 227
 228     if( cdio_read_audio_sectors( p_cdda->p_cdio, p_block->p_buffer,
 229                                  p_cdda->i_lsn, i_blocks) != 0 )
 230     {
 231         msg_Err( p_access, "could not read sector %lu",
 232                  (long unsigned int) p_cdda->i_lsn );
 233         block_Release( p_block );
 234
 235         /* If we had problems above, assume the problem is with
 236            the first sector of the read and set to skip it.  In
 237            the future libcdio may have cdparanoia support.
 238         */
 239         p_cdda->i_lsn++;
 240         p_access->info.i_pos += CDIO_CD_FRAMESIZE_RAW;
 241         return NULL;
 242     }
 243
 244     p_cdda->i_lsn        += i_blocks;
 245     p_access->info.i_pos += p_block->i_buffer;
 246
 247     return p_block;
 248 }
 249
 250 /****************************************************************************
 251  * CDDASeek - change position for subsequent reads. For example, this
 252  * can happen if the user moves a position slider bar in a GUI.
 253  ****************************************************************************/
 254 static int CDDASeek( access_t * p_access, int64_t i_pos )
 255 {
 256     cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
 257
 258     p_cdda->i_lsn = cdio_get_track_lsn(p_cdda->p_cdio, p_cdda->i_track)
 259                   + (i_pos / CDIO_CD_FRAMESIZE_RAW);
 260     p_access->info.i_pos = i_pos;
 261
 262     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_SEEK),
 263                "lsn %lu, offset: %lld",
 264                (long unsigned int) p_cdda->i_lsn, i_pos );
 265     return VLC_SUCCESS;
 266 }
 267
 268 /****************************************************************************
 269  * Public functions
 270  ****************************************************************************/
 271
 272 /*****************************************************************************
 273  * Open: open cdda device or image file and initialize structures
 274  *       for subsequent operations.
 275  *****************************************************************************/
 276 int E_(CDDAOpen)( vlc_object_t *p_this )
 277 {
 278     access_t    *p_access = (access_t*)p_this;
 279     char *      psz_source = NULL;
 280     cdda_data_t *p_cdda    = NULL;
 281     CdIo        *p_cdio;
 282     track_t     i_track = 1;
 283     vlc_bool_t  b_single_track = false;
 284     int         i_rc = VLC_EGENERIC;
 285
 286     p_access->p_sys = NULL;
 287
 288     /* Set where to log errors messages from libcdio. */
 289     p_cdda_input = p_access;
 290
 291     /* parse the options passed in command line : */
 292
 293     if( p_access->psz_path && *p_access->psz_path )
 294     {
 295         char *psz_parser = psz_source = strdup( p_access->psz_path );
 296
 297         while( *psz_parser && *psz_parser != '@' )
 298         {
 299             psz_parser++;
 300         }
 301
 302         if( *psz_parser == '@' )
 303         {
 304             /* Found options */
 305             *psz_parser = '\0';
 306             ++psz_parser;
 307
 308             if ('T' == *psz_parser || 't' == *psz_parser )
 309             ++psz_parser;
 310
 311             i_track = (int)strtol( psz_parser, NULL, 10 );
 312             i_track = i_track ? i_track : 1;
 313             b_single_track = true;
 314         }
 315     }
 316
 317     if (!psz_source || !*psz_source)
 318     {
 319         /* No device/track given. Continue only when this plugin was
 320            selected */
 321         if( !p_this->b_force ) return VLC_EGENERIC;
 322
 323         psz_source = var_CreateGetString( p_this, "cd-audio" );
 324
 325         if( !psz_source || !*psz_source )
 326         {
 327             /* Scan for a CD-ROM drive with a CD-DA in it. */
 328             char **cd_drives =
 329               cdio_get_devices_with_cap(NULL,  CDIO_FS_AUDIO, false);
 330
 331             if (NULL == cd_drives || NULL == cd_drives[0] )
 332             {
 333                 msg_Err( p_access,
 334                      "libcdio couldn't find something with a CD-DA in it" );
 335                 if (cd_drives) cdio_free_device_list(cd_drives);
 336                 return VLC_EGENERIC;
 337             }
 338
 339             psz_source = strdup(cd_drives[0]);
 340             cdio_free_device_list(cd_drives);
 341         }
 342     }
 343
 344     cdio_log_set_handler ( cdio_log_handler );
 345
 346     /* Open CDDA */
 347     if( !(p_cdio = cdio_open( psz_source, DRIVER_UNKNOWN )) )
 348     {
 349         msg_Warn( p_access, "could not open %s", psz_source );
 350         if (psz_source) free( psz_source );
 351         return VLC_EGENERIC;
 352     }
 353
 354     p_cdda = malloc( sizeof(cdda_data_t) );
 355     if( p_cdda == NULL )
 356     {
 357         msg_Err( p_access, "out of memory" );
 358         free( psz_source );
 359         return VLC_ENOMEM;
 360     }
 361     memset( p_cdda, 0, sizeof(cdda_data_t) );
 362
 363 #ifdef HAVE_LIBCDDB
 364     cddb_log_set_handler ( cddb_log_handler );
 365     p_cdda->cddb.disc = NULL;
 366     p_cdda->b_cddb_enabled =
 367       config_GetInt( p_access, MODULE_STRING "-cddb-enabled" );
 368 #endif
 369
 370     p_cdda->b_cdtext_enabled =
 371       config_GetInt( p_access, MODULE_STRING "-cdtext-enabled" );
 372
 373     p_cdda->b_cdtext_prefer =
 374       config_GetInt( p_access, MODULE_STRING "-cdtext-prefer" );
 375
 376     p_cdda->psz_source = strdup(psz_source);
 377     p_cdda->b_header   = VLC_FALSE;
 378     p_cdda->p_cdio     = p_cdio;
 379     p_cdda->i_tracks   = 0;
 380     p_cdda->i_titles   = 0;
 381     p_cdda->i_track    = i_track;
 382     p_cdda->i_debug    = config_GetInt(p_this, MODULE_STRING "-debug");
 383     p_cdda->i_blocks_per_read
 384       = config_GetInt(p_this, MODULE_STRING "-blocks-per-read");
 385
 386     p_cdda->p_input  = vlc_object_find( p_access, VLC_OBJECT_INPUT,
 387                                         FIND_PARENT );
 388
 389     if (0 == p_cdda->i_blocks_per_read)
 390         p_cdda->i_blocks_per_read = DEFAULT_BLOCKS_PER_READ;
 391
 392     if ( p_cdda->i_blocks_per_read < MIN_BLOCKS_PER_READ
 393          || p_cdda->i_blocks_per_read > MAX_BLOCKS_PER_READ )
 394     {
 395         msg_Warn( p_cdda_input,
 396                 "Number of blocks (%d) has to be between %d and %d. "
 397                 "Using %d.",
 398                 p_cdda->i_blocks_per_read,
 399                 MIN_BLOCKS_PER_READ, MAX_BLOCKS_PER_READ,
 400                 DEFAULT_BLOCKS_PER_READ );
 401         p_cdda->i_blocks_per_read = DEFAULT_BLOCKS_PER_READ;
 402     }
 403
 404     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "%s", psz_source );
 405
 406     /* Set up p_access */
 407     p_access->pf_read    = NULL;
 408     p_access->pf_block   = CDDAReadBlocks;
 409     p_access->pf_control = CDDAControl;
 410     p_access->pf_seek    = CDDASeek;
 411
 412     p_access->info.i_size      = 0;
 413
 414     p_access->info.i_update    = 0;
 415     p_access->info.b_eof       = VLC_FALSE;
 416     p_access->info.i_title     = 0;
 417     p_access->info.i_seekpoint = 0;
 418
 419     p_access->p_sys     = (access_sys_t *) p_cdda;
 420
 421     /* We read the Table Of Content information */
 422     i_rc = CDDAInit( p_access, p_cdda );
 423     if ( VLC_SUCCESS != i_rc ) goto error;
 424
 425     CDDAFixupPlaylist( p_access, p_cdda, b_single_track );
 426
 427     /* Build a WAV header to put in front of the output data.
 428        This gets sent back in the Block (read) routine.
 429      */
 430     memset( &p_cdda->waveheader, 0, sizeof(WAVEHEADER) );
 431     SetWLE( &p_cdda->waveheader.Format, 1 ); /*WAVE_FORMAT_PCM*/
 432     SetWLE( &p_cdda->waveheader.BitsPerSample, 16);
 433     p_cdda->waveheader.MainChunkID = VLC_FOURCC('R', 'I', 'F', 'F');
 434     p_cdda->waveheader.Length = 0;                     /* we just don't know */
 435     p_cdda->waveheader.ChunkTypeID = VLC_FOURCC('W', 'A', 'V', 'E');
 436     p_cdda->waveheader.SubChunkID  = VLC_FOURCC('f', 'm', 't', ' ');
 437     SetDWLE( &p_cdda->waveheader.SubChunkLength, 16);
 438     SetWLE( &p_cdda->waveheader.Modus, 2);
 439     SetDWLE( &p_cdda->waveheader.SampleFreq, CDDA_FREQUENCY_SAMPLE);
 440     SetWLE( &p_cdda->waveheader.BytesPerSample,
 441             2 /*Modus*/ * 16 /*BitsPerSample*/ / 8 );
 442     SetDWLE( &p_cdda->waveheader.BytesPerSec,
 443              2*16/8 /*BytesPerSample*/ * CDDA_FREQUENCY_SAMPLE );
 444     p_cdda->waveheader.DataChunkID = VLC_FOURCC('d', 'a', 't', 'a');
 445     p_cdda->waveheader.DataLength  = 0;    /* we just don't know */
 446
 447     /* PTS delay */
 448     var_Create( p_access, MODULE_STRING "-caching",
 449                 VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 450     vlc_object_release( p_cdda->p_input );
 451     return VLC_SUCCESS;
 452
 453  error:
 454     cdio_destroy( p_cdda->p_cdio );
 455     if( psz_source) free( psz_source );
 456     if( p_cdda ) {
 457       if ( p_cdda->p_input )
 458         vlc_object_release( p_cdda->p_input );
 459       free(p_cdda);
 460     }
 461
 462     return i_rc;
 463
 464 }
 465
 466 /*****************************************************************************
 467  * CDDAClose: closes cdda and frees any resources associded with it.
 468  *****************************************************************************/
 469 void E_(CDDAClose)( vlc_object_t *p_this )
 470 {
 471     access_t    *p_access = (access_t *) p_this;
 472     cdda_data_t *p_cdda   = (cdda_data_t *) p_access->p_sys;
 473     track_t      i;
 474
 475     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "" );
 476
 477     /* Remove playlist titles */
 478     for( i = 0; i < p_cdda->i_titles; i++ )
 479     {
 480         vlc_input_title_Delete( p_cdda->p_title[i] );
 481     }
 482
 483     cdio_destroy( p_cdda->p_cdio );
 484
 485     cdio_log_set_handler (uninit_log_handler);
 486
 487 #ifdef HAVE_LIBCDDB
 488     cddb_log_set_handler ((cddb_log_handler_t) uninit_log_handler);
 489     if (p_cdda->b_cddb_enabled)
 490       cddb_disc_destroy(p_cdda->cddb.disc);
 491 #endif
 492
 493     if (p_cdda->psz_mcn)    free( p_cdda->psz_mcn );
 494     if (p_cdda->psz_source) free( p_cdda->psz_source );
 495     free( p_cdda );
 496     p_cdda_input = NULL;
 497 }
 498
 499 /*****************************************************************************
 500  * Control: The front-end or vlc engine calls here to ether get
 501  * information such as meta information or plugin capabilities or to
 502  * issue miscellaneous "set" requests.
 503  *****************************************************************************/
 504 static int CDDAControl( access_t *p_access, int i_query, va_list args )
 505 {
 506     cdda_data_t  *p_cdda = (cdda_data_t *) p_access->p_sys;
 507     int          *pi_int;
 508     int i;
 509
 510     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_EVENT),
 511                "query %d", i_query );
 512
 513     switch( i_query )
 514     {
 515         /* Pass back a copy of meta information that was gathered when we
 516            during the Open/Initialize call.
 517          */
 518         case ACCESS_GET_META:
 519         {
 520             vlc_meta_t **pp_meta = (vlc_meta_t**)va_arg( args, vlc_meta_t** );
 521             if ( p_cdda->p_meta )
 522             {
 523                 *pp_meta = vlc_meta_Duplicate( p_cdda->p_meta );
 524                 dbg_print( INPUT_DBG_META, "%s", "Meta copied" );
 525                 return VLC_SUCCESS;
 526             }
 527             else {
 528                 msg_Warn( p_access, "tried to copy NULL meta info" );
 529                 return VLC_EGENERIC;
 530             }
 531         }
 532
 533         case ACCESS_CAN_SEEK:
 534         case ACCESS_CAN_FASTSEEK:
 535         case ACCESS_CAN_PAUSE:
 536         case ACCESS_CAN_CONTROL_PACE:
 537         {
 538             vlc_bool_t *pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
 539             *pb_bool = VLC_TRUE;
 540             return VLC_SUCCESS;;
 541         }
 542
 543         /* */
 544         case ACCESS_GET_MTU:
 545         {
 546             pi_int = (int*)va_arg( args, int * );
 547             *pi_int = p_cdda-> i_blocks_per_read * CDIO_CD_FRAMESIZE_RAW;
 548             break;
 549         }
 550
 551         case ACCESS_GET_PTS_DELAY:
 552         {
 553             int64_t *pi_64 = (int64_t*)va_arg( args, int64_t * );
 554             *pi_64 = var_GetInteger( p_access, MODULE_STRING "-caching" )
 555               * MILLISECONDS_PER_SEC;
 556             break;
 557         }
 558
 559         /* */
 560         case ACCESS_SET_PAUSE_STATE:
 561             break;
 562
 563         case ACCESS_GET_TITLE_INFO:
 564         {
 565             unsigned int psz_mrl_max = strlen(CDDA_MRL_PREFIX)
 566               + strlen(p_cdda->psz_source) + 1;
 567             input_title_t ***ppp_title =
 568               (input_title_t***)va_arg( args, input_title_t*** );
 569             char *psz_mrl = malloc( psz_mrl_max );
 570
 571             pi_int    = (int*)va_arg( args, int* );
 572             *((int*)va_arg( args, int* )) = 1; /* Title offset */
 573
 574             dbg_print ( INPUT_DBG_EVENT,
 575                         "GET TITLE: i_tracks %d, i_tracks %d",
 576                         p_cdda->i_tracks, p_cdda->i_tracks );
 577
 578             if( psz_mrl == NULL ) {
 579                msg_Warn( p_access, "out of memory" );
 580             } else {
 581                snprintf(psz_mrl, psz_mrl_max, "%s%s",
 582                         CDDA_MRL_PREFIX, p_cdda->psz_source);
 583                CDDAMetaInfo( p_access, -1, psz_mrl );
 584                free(psz_mrl);
 585             }
 586
 587             /* Duplicate title info */
 588             if( p_cdda->i_titles == 0 )
 589             {
 590                 *pi_int = 0; ppp_title = NULL;
 591                 return VLC_SUCCESS;
 592             }
 593             *pi_int = p_cdda->i_titles;
 594             *ppp_title = malloc(sizeof( input_title_t **) * p_cdda->i_titles );
 595
 596             if (!*ppp_title) return VLC_ENOMEM;
 597
 598             for( i = 0; i < p_cdda->i_titles; i++ )
 599             {
 600               if ( p_cdda->p_title[i] ) {
 601                    (*ppp_title)[i] =
 602                      vlc_input_title_Duplicate( p_cdda->p_title[i] );
 603               }
 604             }
 605             break;
 606         }
 607
 608         case ACCESS_SET_TITLE:
 609         {
 610             i = (int)va_arg( args, int );
 611
 612             dbg_print( INPUT_DBG_EVENT, "set title %d", i );
 613             if( i != p_access->info.i_title )
 614             {
 615                 /* Update info */
 616                 p_access->info.i_update |=
 617                     INPUT_UPDATE_TITLE|INPUT_UPDATE_SIZE;
 618                 p_access->info.i_title = i;
 619                 p_access->info.i_size = p_cdda->p_title[i]->i_size;
 620                 p_access->info.i_pos = 0;
 621
 622                 /* Next sector to read */
 623                 p_cdda->i_lsn =
 624                   cdio_get_track_lsn(p_cdda->p_cdio, p_cdda->i_first_track+i);
 625             }
 626             break;
 627         }
 628
 629         case ACCESS_SET_SEEKPOINT:
 630         case ACCESS_SET_PRIVATE_ID_STATE:
 631             return VLC_EGENERIC;
 632
 633         default:
 634             msg_Warn( p_access, "unimplemented query in control" );
 635             return VLC_EGENERIC;
 636
 637     }
 638     return VLC_SUCCESS;
 639 }
 640
 641 /*****************************************************************************
 642   CDDAInit:
 643
 644  Initialize information pertaining to the CD: the number of tracks,
 645  first track number, LSNs for each track and the leadout. The leadout
 646  information is stored after the last track. The LSN array is
 647  0-origin, same as p_access->info.  Add first_track to get what track
 648  number this is on the CD. Note: libcdio uses the real track number.
 649
 650  On input we assume p_cdda->p_cdio and p_cdda->i_track have been set.
 651
 652  We return the VLC-type status, e.g. VLC_SUCCESS, VLC_ENOMEM, etc.
 653  *****************************************************************************/
 654 static int CDDAInit( access_t *p_access, cdda_data_t *p_cdda )
 655 {
 656     discmode_t  discmode = CDIO_DISC_MODE_NO_INFO;
 657
 658     p_cdda->i_tracks       = cdio_get_num_tracks(p_cdda->p_cdio);
 659     p_cdda->i_first_track  = cdio_get_first_track_num(p_cdda->p_cdio);
 660
 661     discmode = cdio_get_discmode(p_cdda->p_cdio);
 662     switch(discmode) {
 663     case CDIO_DISC_MODE_CD_DA:
 664     case CDIO_DISC_MODE_CD_MIXED:
 665         /* These are possible for CD-DA */
 666         break;
 667     default:
 668         /* These are not possible for CD-DA */
 669         msg_Err( p_access,
 670                "Disc seems not to be CD-DA. libcdio reports it is %s",
 671                discmode2str[discmode]
 672                );
 673         return VLC_EGENERIC;
 674     }
 675
 676     /* Set reading start LSN. */
 677     p_cdda->i_lsn = cdio_get_track_lsn(p_cdda->p_cdio, p_cdda->i_track);
 678
 679     return VLC_SUCCESS;
 680 }
 681
 682 /*
 683  * Local variables:
 684  *  mode: C
 685  *  style: gnu
 686  * End:
 687  */