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

   1 /*****************************************************************************
   2  * cddax.c : CD digital audio input module for vlc using libcdio
   3  *****************************************************************************
   4  * Copyright (C) 2000,2003 VideoLAN
   5  * $Id: access.c,v 1.12 2003/12/05 01:56:24 rocky Exp $
   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 <stdio.h>
  30 #include <stdlib.h>
  31
  32 #include <vlc/vlc.h>
  33 #include <vlc/intf.h>
  34
  35 #include <sys/types.h>
  36 #include <cdio/cdio.h>
  37 #include <cdio/cd_types.h>
  38
  39 #include "codecs.h"
  40 #include "vlc_keys.h"
  41
  42 #ifdef HAVE_UNISTD_H
  43 #   include <unistd.h>
  44 #endif
  45
  46 #include <string.h>
  47
  48 #include "cdda.h"
  49
  50 /* how many blocks Open will read in each loop */
  51 #define CDDA_BLOCKS_ONCE 1
  52 #define CDDA_DATA_ONCE   (CDDA_BLOCKS_ONCE * CDIO_CD_FRAMESIZE_RAW)
  53
  54 #define CDDA_MRL_PREFIX "cddax://"
  55
  56 /* FIXME: This variable is a hack. Would be nice to eliminate. */
  57 static input_thread_t *p_cdda_input = NULL;
  58
  59 /*****************************************************************************
  60  * Local prototypes
  61  *****************************************************************************/
  62 static int  CDDARead         ( input_thread_t *, byte_t *, size_t );
  63 static void CDDASeek         ( input_thread_t *, off_t );
  64 static int  CDDASetArea      ( input_thread_t *, input_area_t * );
  65 static int  CDDASetProgram   ( input_thread_t *, pgrm_descriptor_t * );
  66
  67 static int  CDDAFixupPlayList( input_thread_t *p_input,
  68                               cdda_data_t *p_cdda, const char *psz_source,
  69                               bool play_single_track);
  70
  71 /****************************************************************************
  72  * Private functions
  73  ****************************************************************************/
  74
  75 /* process messages that originate from libcdio. */
  76 static void
  77 cdio_log_handler (cdio_log_level_t level, const char message[])
  78 {
  79   cdda_data_t *p_cdda = (cdda_data_t *)p_cdda_input->p_access_data;
  80   switch (level) {
  81   case CDIO_LOG_DEBUG:
  82   case CDIO_LOG_INFO:
  83     if (p_cdda->i_debug & INPUT_DBG_CDIO)
  84       msg_Dbg( p_cdda_input, message);
  85     break;
  86   case CDIO_LOG_WARN:
  87     msg_Warn( p_cdda_input, message);
  88     break;
  89   case CDIO_LOG_ERROR:
  90   case CDIO_LOG_ASSERT:
  91     msg_Err( p_cdda_input, message);
  92     break;
  93   default:
  94     msg_Warn( p_cdda_input, message,
  95             _("The above message had unknown vcdimager log level"),
  96             level);
  97   }
  98   return;
  99 }
 100
 101
 102 #ifdef HAVE_LIBCDDB
 103 /*! This routine is called by libcddb routines on error.
 104    Setup is done by init_input_plugin.
 105 */
 106 static void
 107 cddb_log_handler (cddb_log_level_t level, const char message[])
 108 {
 109   cdda_data_t *p_cdda = (cdda_data_t *)p_cdda_input->p_access_data;
 110   switch (level) {
 111   case CDDB_LOG_DEBUG:
 112   case CDDB_LOG_INFO:
 113     if (!(p_cdda->i_debug & INPUT_DBG_CDDB)) return;
 114     /* Fall through if to warn case */
 115   default:
 116     cdio_log_handler (level, message);
 117   }
 118 }
 119 #endif /*HAVE_LIBCDDB*/
 120
 121
 122 /*! This routine is when xine is not fully set up (before full initialization)
 123    or is not around (before finalization).
 124 */
 125 static void
 126 uninit_log_handler (cdio_log_level_t level, const char message[])
 127 {
 128   cdda_data_t *p_cdda = (cdda_data_t *)p_cdda_input->p_access_data;
 129   switch (level) {
 130   case CDIO_LOG_DEBUG:
 131   case CDIO_LOG_INFO:
 132     if (!(p_cdda->i_debug & (INPUT_DBG_CDIO|INPUT_DBG_CDDB)))
 133       return;
 134     /* Fall through if to warn case */
 135   case CDIO_LOG_WARN:
 136     fprintf(stderr, "WARN: %s\n", message);
 137     break;
 138   case CDIO_LOG_ERROR:
 139     fprintf(stderr, "ERROR: %s\n", message);
 140     break;
 141   case CDIO_LOG_ASSERT:
 142     fprintf(stderr, "ASSERT ERROR: %s\n", message);
 143     break;
 144   default:
 145     fprintf(stderr, "UNKNOWN ERROR: %s\n%s %d\n",
 146             message,
 147             _("The above message had unknown cdio log level"),
 148             level);
 149   }
 150
 151   /* gl_default_cdio_log_handler (level, message); */
 152 }
 153
 154 /*****************************************************************************
 155  * CDDAPlay: Arrange things so we play the specified track.
 156  * VLC_TRUE is returned if there was no error.
 157  *****************************************************************************/
 158 vlc_bool_t
 159 CDDAPlay( input_thread_t *p_input, int i_track )
 160 {
 161   cdda_data_t *p_cdda = (cdda_data_t *) p_input->p_access_data;
 162
 163   if( i_track >= p_cdda->i_nb_tracks || i_track < 1 )
 164     return VLC_FALSE;
 165
 166   CDDASetArea( p_input, p_input->stream.pp_areas[i_track] );
 167   return VLC_TRUE;
 168 }
 169
 170 /*****************************************************************************
 171  * CDDARead: reads from the CDDA into PES packets.
 172  *****************************************************************************
 173  * Returns -1 in case of error, 0 in case of EOF, otherwise the number of
 174  * bytes.
 175  *****************************************************************************/
 176 static int CDDARead( input_thread_t * p_input, byte_t * p_buffer,
 177                      size_t i_len )
 178 {
 179     cdda_data_t *           p_cdda;
 180     int                     i_blocks;
 181     int                     i_index;
 182     int                     i_read;
 183
 184     p_cdda = (cdda_data_t *)p_input->p_access_data;
 185
 186     i_read = 0;
 187
 188     /* Compute the number of blocks we have to read */
 189
 190     i_blocks = i_len / CDIO_CD_FRAMESIZE_RAW;
 191
 192     for ( i_index = 0; i_index < i_blocks; i_index++ )
 193     {
 194
 195       if (cdio_read_audio_sector(p_cdda->p_cddev->cdio, p_buffer,
 196                                  p_cdda->i_sector) != 0)
 197         {
 198           msg_Err( p_input, "could not read sector %d", p_cdda->i_sector );
 199           return -1;
 200         }
 201
 202         p_cdda->i_sector ++;
 203         if ( p_cdda->i_sector == p_cdda->p_sectors[p_cdda->i_track + 1] )
 204         {
 205             input_area_t *p_area;
 206
 207             dbg_print( (INPUT_DBG_LSN|INPUT_DBG_CALL),
 208                        "end of track, cur: %u", p_cdda->i_sector );
 209
 210             /*???? if ( p_cdda->i_track >= p_cdda->i_nb_tracks - 1 )*/
 211                 return 0; /* EOF */
 212
 213             vlc_mutex_lock( &p_input->stream.stream_lock );
 214             p_area = p_input->stream.pp_areas[
 215                     p_input->stream.p_selected_area->i_id + 1 ];
 216
 217             p_area->i_part = 1;
 218             CDDASetArea( p_input, p_area );
 219             vlc_mutex_unlock( &p_input->stream.stream_lock );
 220         }
 221         i_read += CDIO_CD_FRAMESIZE_RAW;
 222     }
 223
 224     if ( i_len % CDIO_CD_FRAMESIZE_RAW ) /* this should not happen */
 225     {
 226         msg_Err( p_input, "must read full sectors" );
 227     }
 228
 229     return i_read;
 230 }
 231
 232 /*****************************************************************************
 233  * CDDASetProgram: Does nothing since a CDDA is mono_program
 234  *****************************************************************************/
 235 static int CDDASetProgram( input_thread_t * p_input,
 236                            pgrm_descriptor_t * p_program)
 237 {
 238     cdda_data_t * p_cdda= (cdda_data_t *) p_input->p_access_data;
 239     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "" );
 240     return 0;
 241 }
 242
 243 /*****************************************************************************
 244  * CDDASetArea: initialize input data for title x.
 245  * It should be called for each user navigation request.
 246  ****************************************************************************/
 247 static int CDDASetArea( input_thread_t * p_input, input_area_t * p_area )
 248 {
 249     cdda_data_t *p_cdda = (cdda_data_t*) p_input->p_access_data;
 250     vlc_value_t val;
 251
 252     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "");
 253
 254     /* we can't use the interface slider until initilization is complete */
 255     p_input->stream.b_seekable = 0;
 256
 257     if( p_area != p_input->stream.p_selected_area )
 258     {
 259         /* Change the default area */
 260         p_input->stream.p_selected_area = p_area;
 261
 262         /* Change the current track */
 263         p_cdda->i_track = p_area->i_id - 1;
 264         p_cdda->i_sector = p_cdda->p_sectors[p_cdda->i_track];
 265
 266         /* Update the navigation variables without triggering a callback */
 267         val.i_int = p_area->i_id;
 268         var_Change( p_input, "title", VLC_VAR_SETVALUE, &val, NULL );
 269     }
 270
 271     p_cdda->i_sector = p_cdda->p_sectors[p_cdda->i_track];
 272
 273     p_input->stream.p_selected_area->i_tell =
 274         (off_t)p_cdda->i_sector * (off_t)CDIO_CD_FRAMESIZE_RAW
 275          - p_input->stream.p_selected_area->i_start;
 276
 277     /* warn interface that something has changed */
 278     p_input->stream.b_seekable = 1;
 279     p_input->stream.b_changed = 1;
 280
 281     return 0;
 282 }
 283
 284 /****************************************************************************
 285  * CDDASeek
 286  ****************************************************************************/
 287 static void CDDASeek( input_thread_t * p_input, off_t i_off )
 288 {
 289     cdda_data_t * p_cdda;
 290
 291     p_cdda = (cdda_data_t *) p_input->p_access_data;
 292
 293     p_cdda->i_sector = p_cdda->p_sectors[p_cdda->i_track]
 294                        + i_off / (off_t)CDIO_CD_FRAMESIZE_RAW;
 295
 296     vlc_mutex_lock( &p_input->stream.stream_lock );
 297     p_input->stream.p_selected_area->i_tell =
 298         (off_t)p_cdda->i_sector * (off_t)CDIO_CD_FRAMESIZE_RAW
 299          - p_input->stream.p_selected_area->i_start;
 300
 301     vlc_mutex_unlock( &p_input->stream.stream_lock );
 302
 303     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT|INPUT_DBG_SEEK),
 304     "sector %ud, offset: %lld, i_tell: %lld",  p_cdda->i_sector, i_off,
 305                p_input->stream.p_selected_area->i_tell );
 306
 307 }
 308
 309 #define meta_info_add_str(title, str) \
 310   if ( str ) {                                                          \
 311     dbg_print( INPUT_DBG_META, "field %s: %s\n", title, str);   \
 312     input_AddInfo( p_cat, _(title), "%s", str );                        \
 313   }
 314
 315
 316 static void InformationCreate( input_thread_t *p_input  )
 317 {
 318   cdda_data_t *p_cdda = (cdda_data_t *) p_input->p_access_data;
 319   input_info_category_t *p_cat;
 320
 321   p_cat = input_InfoCategory( p_input, "General" );
 322
 323 #ifdef HAVE_LIBCDDB
 324   if (p_cdda->i_cddb_enabled) {
 325
 326     meta_info_add_str( "Title", p_cdda->cddb.disc->title );
 327     meta_info_add_str( "Artist", p_cdda->cddb.disc->artist );
 328     meta_info_add_str( "Genre", p_cdda->cddb.disc->genre );
 329     meta_info_add_str( "Extended Data", p_cdda->cddb.disc->ext_data );
 330     {
 331       char year[5];
 332       if (p_cdda->cddb.disc->year != 0) {
 333         snprintf(year, 5, "%d", p_cdda->cddb.disc->year);
 334         meta_info_add_str( "Year", year );
 335       }
 336       if ( p_cdda->cddb.disc->discid ) {
 337         input_AddInfo( p_cat, _("CDDB Disc ID"), "%x",
 338                        p_cdda->cddb.disc->discid );
 339       }
 340
 341       if ( p_cdda->cddb.disc->category != CDDB_CAT_INVALID ) {
 342         input_AddInfo( p_cat, _("CDDB Disc Category"), "%s",
 343                        CDDB_CATEGORY[p_cdda->cddb.disc->category] );
 344       }
 345
 346     }
 347   }
 348
 349 #endif /*HAVE_LIBCDDB*/
 350
 351   {
 352     track_t i_track = p_cdda->i_nb_tracks;
 353     char psz_buffer[MSTRTIME_MAX_SIZE];
 354     mtime_t i_duration =
 355       (p_cdda->p_sectors[i_track] - p_cdda->p_sectors[0])
 356       / CDIO_CD_FRAMES_PER_SEC;
 357
 358     dbg_print( INPUT_DBG_META, "Duration %ld", (long int) i_duration );
 359     input_AddInfo( p_cat, _("Duration"), "%s",
 360                    secstotimestr( psz_buffer, i_duration ) );
 361   }
 362 }
 363
 364
 365 #ifdef HAVE_LIBCDDB
 366
 367 #define free_and_dup(var, val) \
 368   if (var) free(var);          \
 369   if (val) var=strdup(val);
 370
 371
 372 static void
 373 GetCDDBInfo( const input_thread_t *p_input, cdda_data_t *p_cdda )
 374 {
 375
 376   dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "" );
 377
 378   if (config_GetInt( p_input, MODULE_STRING "-cddb-enabled" )) {
 379     int i, i_matches;
 380     cddb_conn_t  *conn = cddb_new();
 381     const CdIo *cdio = p_cdda->p_cddev->cdio;
 382
 383
 384     cddb_log_set_handler (uninit_log_handler);
 385
 386     if (!conn) {
 387       msg_Warn( p_input, "unable to initialize libcddb" );
 388       goto cddb_destroy;
 389     }
 390
 391     cddb_set_email_address( conn,
 392                             config_GetPsz( p_input,
 393                                            MODULE_STRING "-cddb-email") );
 394
 395     cddb_set_server_name( conn,
 396                           config_GetPsz( p_input,
 397                                          MODULE_STRING "-cddb-server") );
 398
 399     cddb_set_server_port(conn,
 400                           config_GetInt( p_input,
 401                                          MODULE_STRING "-cddb-port") );
 402
 403     /* Set the location of the local CDDB cache directory.
 404        The default location of this directory is */
 405
 406     if (!config_GetInt( p_input, MODULE_STRING "-cddb-enable-cache" ))
 407       cddb_cache_disable(conn);
 408
 409     cddb_cache_set_dir(conn,
 410                        config_GetPsz( p_input,
 411                                       MODULE_STRING "-cddb-cachedir") );
 412
 413     cddb_set_timeout(conn,
 414                      config_GetInt( p_input, MODULE_STRING "-cddb-timeout") );
 415
 416
 417     if (config_GetInt( p_input, MODULE_STRING "-cddb-httpd" )) {
 418       cddb_http_enable(conn);
 419     } else
 420       cddb_http_disable(conn);
 421
 422     p_cdda->cddb.disc = cddb_disc_new();
 423     if (!p_cdda->cddb.disc) {
 424       msg_Err( p_input, "Unable to create CDDB disc structure." );
 425       goto cddb_end;
 426     }
 427
 428     for(i = 1; i <= p_cdda->i_nb_tracks; i++) {
 429       cddb_track_t *t = cddb_track_new();
 430       t->frame_offset = cdio_get_track_lba(cdio, i);
 431       cddb_disc_add_track(p_cdda->cddb.disc, t);
 432     }
 433
 434     p_cdda->cddb.disc->length =
 435       cdio_get_track_lba(cdio, CDIO_CDROM_LEADOUT_TRACK)
 436       / CDIO_CD_FRAMES_PER_SEC;
 437
 438
 439     if (!cddb_disc_calc_discid(p_cdda->cddb.disc)) {
 440       msg_Err( p_input, "CDDB disc calc failed" );
 441       goto cddb_destroy;
 442     }
 443
 444     i_matches = cddb_query(conn, p_cdda->cddb.disc);
 445     if (i_matches > 0) {
 446       if (i_matches > 1)
 447         msg_Warn( p_input, "Found %d matches in CDDB. Using first one.",
 448                   i_matches);
 449       cddb_read(conn, p_cdda->cddb.disc);
 450
 451       if (p_cdda->i_debug & INPUT_DBG_CDDB)
 452         cddb_disc_print(p_cdda->cddb.disc);
 453
 454     } else {
 455       msg_Warn( p_input, "CDDB error: %s", cddb_error_str(errno));
 456     }
 457
 458   cddb_destroy:
 459     cddb_destroy(conn);
 460   }
 461   cddb_end: ;
 462 }
 463 #endif /*HAVE_LIBCDDB*/
 464
 465 #define add_format_str_info(val)                        \
 466   {                                                     \
 467     const char *str = val;                              \
 468     unsigned int len;                                   \
 469     if (val != NULL) {                                  \
 470       len=strlen(str);                                  \
 471       if (len != 0) {                                   \
 472         strncat(tp, str, TEMP_STR_LEN-(tp-temp_str));   \
 473         tp += len;                                      \
 474       }                                                 \
 475       saw_control_prefix = false;                       \
 476     }                                                   \
 477   }
 478
 479 #define add_format_num_info(val, fmt)                   \
 480   {                                                     \
 481     char num_str[10];                                   \
 482     unsigned int len;                                   \
 483     sprintf(num_str, fmt, val);                         \
 484     len=strlen(num_str);                                \
 485     if (len != 0) {                                     \
 486       strncat(tp, num_str, TEMP_STR_LEN-(tp-temp_str)); \
 487       tp += len;                                        \
 488     }                                                   \
 489     saw_control_prefix = false;                         \
 490   }
 491
 492 /*!
 493    Take a format string and expand escape sequences, that is sequences that
 494    begin with %, with information from the current CD.
 495    The expanded string is returned. Here is a list of escape sequences:
 496
 497    %a : The album artist **
 498    %A : The album information **
 499    %C : Category **
 500    %I : CDDB disk ID **
 501    %G : Genre **
 502    %M : The current MRL
 503    %m : The CD-DA Media Catalog Number (MCN)
 504    %n : The number of tracks on the CD
 505    %p : The artist/performer/composer in the track **
 506    %T : The track number **
 507    %s : Number of seconds in this track
 508    %t : The name **
 509    %Y : The year 19xx or 20xx **
 510    %% : a %
 511 */
 512 static char *
 513 CDDAFormatStr(const input_thread_t *p_input, cdda_data_t *p_cdda,
 514               const char format_str[], const char *mrl, int i_track)
 515 {
 516 #define TEMP_STR_SIZE 256
 517 #define TEMP_STR_LEN (TEMP_STR_SIZE-1)
 518   static char    temp_str[TEMP_STR_SIZE];
 519   size_t i;
 520   char * tp = temp_str;
 521   bool saw_control_prefix = false;
 522   size_t format_len = strlen(format_str);
 523
 524   bzero(temp_str, TEMP_STR_SIZE);
 525
 526   for (i=0; i<format_len; i++) {
 527
 528     if (!saw_control_prefix && format_str[i] != '%') {
 529       *tp++ = format_str[i];
 530       saw_control_prefix = false;
 531       continue;
 532     }
 533
 534     switch(format_str[i]) {
 535     case '%':
 536       if (saw_control_prefix) {
 537         *tp++ = '%';
 538       }
 539       saw_control_prefix = !saw_control_prefix;
 540       break;
 541 #ifdef HAVE_LIBCDDB
 542     case 'a':
 543       if (!p_cdda->i_cddb_enabled) goto not_special;
 544       add_format_str_info(p_cdda->cddb.disc->artist);
 545       break;
 546     case 'A':
 547       if (!p_cdda->i_cddb_enabled) goto not_special;
 548       add_format_str_info(p_cdda->cddb.disc->title);
 549       break;
 550     case 'C':
 551       if (!p_cdda->i_cddb_enabled) goto not_special;
 552       add_format_str_info(CDDB_CATEGORY[p_cdda->cddb.disc->category]);
 553       break;
 554     case 'G':
 555       if (!p_cdda->i_cddb_enabled) goto not_special;
 556       add_format_str_info(p_cdda->cddb.disc->genre);
 557       break;
 558     case 'I':
 559       if (!p_cdda->i_cddb_enabled) goto not_special;
 560       add_format_num_info(p_cdda->cddb.disc->discid, "%x");
 561       break;
 562     case 'Y':
 563       if (!p_cdda->i_cddb_enabled) goto not_special;
 564       add_format_num_info(p_cdda->cddb.disc->year, "%5d");
 565       break;
 566     case 't':
 567       if (p_cdda->i_cddb_enabled) {
 568         cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
 569                                             i_track-1);
 570         if (t != NULL && t->title != NULL)
 571           add_format_str_info(t->title);
 572       } else goto not_special;
 573       break;
 574     case 'p':
 575       if (p_cdda->i_cddb_enabled) {
 576         cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
 577                                             i_track-1);
 578         if (t != NULL && t->artist != NULL)
 579           add_format_str_info(t->artist);
 580       } else goto not_special;
 581       break;
 582 #endif
 583
 584     case 'M':
 585       add_format_str_info(mrl);
 586       break;
 587
 588 #if FINISHED
 589     case 'm':
 590       add_format_str_info(p_cdda->mcn);
 591       break;
 592 #endif
 593
 594     case 'n':
 595       add_format_num_info(p_cdda->i_nb_tracks, "%d");
 596       break;
 597
 598     case 's':
 599       if (p_cdda->i_cddb_enabled) {
 600         char psz_buffer[MSTRTIME_MAX_SIZE];
 601         mtime_t i_duration =
 602           (p_cdda->p_sectors[i_track] - p_cdda->p_sectors[i_track-1])
 603           / CDIO_CD_FRAMES_PER_SEC;
 604         add_format_str_info(secstotimestr( psz_buffer, i_duration ) );
 605       } else goto not_special;
 606       break;
 607
 608     case 'T':
 609       add_format_num_info(i_track, "%02d");
 610       break;
 611 #ifdef HAVE_LIBCDDB
 612     not_special:
 613 #endif
 614     default:
 615       *tp++ = '%';
 616       *tp++ = format_str[i];
 617       saw_control_prefix = false;
 618     }
 619   }
 620   return strdup(temp_str);
 621 }
 622
 623 static void
 624 CDDACreatePlayListItem(const input_thread_t *p_input, cdda_data_t *p_cdda,
 625                        playlist_t *p_playlist, unsigned int i_track,
 626                        char *psz_mrl, int psz_mrl_max,
 627                        const char *psz_source, int playlist_operation,
 628                        unsigned int i_pos)
 629 {
 630   mtime_t i_duration =
 631     (p_cdda->p_sectors[i_track] - p_cdda->p_sectors[i_track-1])
 632     / CDIO_CD_FRAMES_PER_SEC;
 633   char *p_title;
 634   char *config_varname = MODULE_STRING "-title-format";
 635
 636 #ifdef HAVE_LIBCDDB
 637   if (p_cdda->i_cddb_enabled) {
 638     config_varname = MODULE_STRING "-cddb-title-format";
 639   }
 640 #endif
 641
 642   snprintf(psz_mrl, psz_mrl_max, "%s%s@T%u",
 643            CDDA_MRL_PREFIX, psz_source, i_track);
 644
 645   p_title = CDDAFormatStr(p_input, p_cdda,
 646                           config_GetPsz( p_input, config_varname ),
 647                           psz_mrl, i_track);
 648
 649   dbg_print( INPUT_DBG_META, "mrl: %s, title: %s, duration, %ld, pos %d",
 650              psz_mrl, p_title, (long int) i_duration, i_pos );
 651   playlist_AddExt( p_playlist, psz_mrl, p_title, i_duration * 1000000,
 652                    0, 0, playlist_operation, i_pos );
 653 }
 654
 655 static int
 656 CDDAFixupPlayList( input_thread_t *p_input, cdda_data_t *p_cdda,
 657                   const char *psz_source, bool play_single_track)
 658 {
 659   int i;
 660   playlist_t * p_playlist;
 661   char       * psz_mrl;
 662   unsigned int psz_mrl_max = strlen(CDDA_MRL_PREFIX) + strlen(psz_source) +
 663     strlen("@T") + strlen("100") + 1;
 664
 665 #ifdef HAVE_LIBCDDB
 666   p_cdda->i_cddb_enabled =
 667     config_GetInt( p_input, MODULE_STRING "-cddb-enabled" );
 668 #endif
 669
 670   if (play_single_track && !p_cdda->i_cddb_enabled) return 0;
 671
 672   psz_mrl = malloc( psz_mrl_max );
 673
 674   if( psz_mrl == NULL )
 675     {
 676       msg_Warn( p_input, "out of memory" );
 677       return -1;
 678     }
 679
 680   p_playlist = (playlist_t *) vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
 681                                                FIND_ANYWHERE );
 682   if( !p_playlist )
 683     {
 684       msg_Warn( p_input, "can't find playlist" );
 685       free(psz_mrl);
 686       return -1;
 687     }
 688
 689 #ifdef HAVE_LIBCDDB
 690   if (p_cdda->i_cddb_enabled)
 691     GetCDDBInfo(p_input, p_cdda);
 692   else
 693     p_cdda->cddb.disc = NULL;
 694 #endif
 695
 696   InformationCreate(p_input);
 697
 698   if (play_single_track) {
 699     /* May fill out more information when the playlist user interface becomes
 700        more mature.
 701      */
 702     CDDACreatePlayListItem(p_input, p_cdda, p_playlist, p_cdda->i_track+1,
 703                            psz_mrl, psz_mrl_max, psz_source, PLAYLIST_REPLACE,
 704                            p_playlist->i_index);
 705   } else {
 706
 707     playlist_Delete( p_playlist, p_playlist->i_index);
 708
 709     for( i = 1 ; i <= p_cdda->i_nb_tracks ; i++ )
 710       {
 711         CDDACreatePlayListItem(p_input, p_cdda, p_playlist, i, psz_mrl,
 712                                psz_mrl_max, psz_source, PLAYLIST_APPEND,
 713                                PLAYLIST_END);
 714
 715       }
 716
 717     playlist_Command( p_playlist, PLAYLIST_GOTO, 0 );
 718
 719   }
 720
 721   vlc_object_release( p_playlist );
 722   free(psz_mrl);
 723   return 0;
 724 }
 725
 726 /****************************************************************************
 727  * Public functions
 728  ****************************************************************************/
 729 int
 730 E_(DebugCB)   ( vlc_object_t *p_this, const char *psz_name,
 731                 vlc_value_t oldval, vlc_value_t val, void *p_data )
 732 {
 733   cdda_data_t *p_cdda;
 734
 735   if (NULL == p_cdda_input) return VLC_EGENERIC;
 736
 737   p_cdda = (cdda_data_t *)p_cdda_input->p_access_data;
 738
 739   if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) {
 740     msg_Dbg( p_cdda_input, "Old debug (x%0x) %d, new debug (x%0x) %d",
 741              p_cdda->i_debug, p_cdda->i_debug, val.i_int, val.i_int);
 742   }
 743   p_cdda->i_debug = val.i_int;
 744   return VLC_SUCCESS;
 745 }
 746
 747 int
 748 E_(CDDBEnabledCB)   ( vlc_object_t *p_this, const char *psz_name,
 749                       vlc_value_t oldval, vlc_value_t val, void *p_data )
 750 {
 751   cdda_data_t *p_cdda;
 752
 753   if (NULL == p_cdda_input) return VLC_EGENERIC;
 754
 755   p_cdda = (cdda_data_t *)p_cdda_input->p_access_data;
 756
 757   if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) {
 758     msg_Dbg( p_cdda_input, "Old CDDB Enabled (x%0x) %d, new (x%0x) %d",
 759              p_cdda->i_cddb_enabled, p_cdda->i_cddb_enabled,
 760              val.i_int, val.i_int);
 761   }
 762   p_cdda->i_cddb_enabled = val.i_int;
 763   return VLC_SUCCESS;
 764 }
 765
 766 /*FIXME*/
 767 #if PLAYLIST_INTERFACE_IS_FIXED
 768 int
 769 E_(TitleFormatCB)   ( vlc_object_t *p_this, const char *psz_name,
 770                       vlc_value_t oldval, vlc_value_t val, void *p_data )
 771 {
 772   cdda_data_t *p_cdda;
 773
 774   if (NULL == p_cdda_input) return VLC_EGENERIC;
 775
 776   p_cdda = (cdda_data_t *)p_cdda_input->p_access_data;
 777
 778   if (p_cdda->i_debug & (INPUT_DBG_CALL|INPUT_DBG_EXT)) {
 779     msg_Dbg( p_cdda_input, "Old CDDB Enabled (%s), new (%s)",
 780              oldval.psz_string, val.psz_string);
 781   }
 782   ????
 783   return VLC_SUCCESS;
 784 }
 785 #endif
 786
 787 /*****************************************************************************
 788  * Open: open cdda
 789  *****************************************************************************/
 790 int
 791 E_(Open)( vlc_object_t *p_this )
 792 {
 793     input_thread_t *        p_input = (input_thread_t *)p_this;
 794     char *                  psz_orig;
 795     char *                  psz_parser;
 796     char *                  psz_source;
 797     cdda_data_t *           p_cdda;
 798     int                     i;
 799     int                     i_track = 1;
 800     cddev_t                 *p_cddev;
 801     bool                    play_single_track = false;
 802
 803     /* Set where to log errors messages from libcdio. */
 804     p_cdda_input = (input_thread_t *)p_this;
 805
 806     /* parse the options passed in command line : */
 807     psz_orig = psz_parser = psz_source = strdup( p_input->psz_name );
 808
 809     if( !psz_orig )
 810     {
 811         return( -1 );
 812     }
 813
 814     while( *psz_parser && *psz_parser != '@' )
 815     {
 816         psz_parser++;
 817     }
 818
 819     if( *psz_parser == '@' )
 820     {
 821         /* Found options */
 822         *psz_parser = '\0';
 823         ++psz_parser;
 824
 825         if ('T' == *psz_parser || 't' == *psz_parser )
 826             ++psz_parser;
 827
 828         i_track = (int)strtol( psz_parser, NULL, 10 );
 829         i_track = i_track ? i_track : 1;
 830         play_single_track = true;
 831     }
 832
 833     if( !*psz_source ) {
 834       /* No source specified, so figure it out. */
 835       if( !p_input->psz_access ) {
 836         free( psz_orig );
 837         return -1;
 838       }
 839       psz_source = config_GetPsz( p_input, MODULE_STRING "-device" );
 840
 841       if( !psz_source || 0==strlen(psz_source) ) {
 842         /* Scan for a CD-ROM drive with a CD-DA in it. */
 843         char **cd_drives =
 844           cdio_get_devices_with_cap(NULL,  CDIO_FS_AUDIO, false);
 845         if (NULL == cd_drives) return -1;
 846         if (cd_drives[0] == NULL) {
 847           cdio_free_device_list(cd_drives);
 848           return -1;
 849         }
 850         psz_source = strdup(cd_drives[0]);
 851         cdio_free_device_list(cd_drives);
 852       }
 853     }
 854
 855     /* Open CDDA */
 856     cdio_log_set_handler ( cdio_log_handler );
 857 #ifdef HAVE_LIBCDDB
 858     cddb_log_set_handler ( cddb_log_handler );
 859 #endif
 860
 861     if( !(p_cddev = ioctl_Open( p_this, psz_source )) )
 862     {
 863         msg_Warn( p_input, "could not open %s", psz_source );
 864         free( psz_source );
 865         return -1;
 866     }
 867
 868     p_cdda = malloc( sizeof(cdda_data_t) );
 869     if( p_cdda == NULL )
 870     {
 871         msg_Err( p_input, "out of memory" );
 872         free( psz_source );
 873         return -1;
 874     }
 875
 876     p_cdda->p_cddev        = p_cddev;
 877     p_cdda->i_debug        = config_GetInt( p_this, MODULE_STRING "-debug" );
 878     p_input->p_access_data = (void *)p_cdda;
 879
 880     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "%s", psz_source );
 881
 882     p_input->i_mtu = CDDA_DATA_ONCE;
 883
 884     /* We read the Table Of Content information */
 885     p_cdda->i_nb_tracks = ioctl_GetTracksMap( VLC_OBJECT(p_input),
 886                               p_cdda->p_cddev->cdio, &p_cdda->p_sectors );
 887     if( p_cdda->i_nb_tracks < 0 )
 888         msg_Err( p_input, "unable to count tracks" );
 889     else if( p_cdda->i_nb_tracks <= 0 )
 890         msg_Err( p_input, "no audio tracks found" );
 891
 892     if( p_cdda->i_nb_tracks <= 1)
 893     {
 894         ioctl_Close( p_cdda->p_cddev );
 895         free( p_cdda );
 896         free( psz_source );
 897         return -1;
 898     }
 899
 900     if( i_track >= p_cdda->i_nb_tracks || i_track < 1 )
 901         i_track = 1;
 902
 903     /* Set stream and area data */
 904     vlc_mutex_lock( &p_input->stream.stream_lock );
 905
 906     /* Initialize ES structures */
 907     input_InitStream( p_input, 0 );
 908
 909     /* cdda input method */
 910     p_input->stream.i_method = INPUT_METHOD_CDDA;
 911
 912     p_input->stream.b_pace_control = 1;
 913     p_input->stream.b_seekable = 1;
 914     p_input->stream.i_mux_rate = 44100 * 4 / 50;
 915
 916 #define area p_input->stream.pp_areas
 917     for( i = 1 ; i <= p_cdda->i_nb_tracks ; i++ )
 918     {
 919         input_AddArea( p_input, i, 1 );
 920
 921         /* Absolute start offset and size */
 922         area[i]->i_start =
 923             (off_t)p_cdda->p_sectors[i-1] * (off_t)CDIO_CD_FRAMESIZE_RAW;
 924         area[i]->i_size =
 925             (off_t)(p_cdda->p_sectors[i] - p_cdda->p_sectors[i-1])
 926             * (off_t)CDIO_CD_FRAMESIZE_RAW;
 927     }
 928 #undef area
 929
 930     CDDAPlay( p_input, i_track);
 931
 932     CDDAFixupPlayList(p_input, p_cdda, psz_source, play_single_track);
 933
 934     vlc_mutex_unlock( &p_input->stream.stream_lock );
 935
 936     if( !p_input->psz_demux || !*p_input->psz_demux )
 937     {
 938         p_input->psz_demux = "cdda";
 939     }
 940
 941     p_input->pf_read = CDDARead;
 942     p_input->pf_seek = CDDASeek;
 943     p_input->pf_set_area = CDDASetArea;
 944     p_input->pf_set_program = CDDASetProgram;
 945
 946     /* Update default_pts to a suitable value for cdda access */
 947     p_input->i_pts_delay = config_GetInt( p_input,
 948                                           MODULE_STRING "-caching" ) * 1000;
 949
 950     p_cdda->p_intf = intf_Create( p_input, "cddax" );
 951     intf_RunThread( p_cdda->p_intf );
 952     free( psz_source );
 953
 954     return 0;
 955 }
 956
 957 /*****************************************************************************
 958  * CDDAClose: closes cdda
 959  *****************************************************************************/
 960 void
 961 E_(Close)( vlc_object_t *p_this )
 962 {
 963     input_thread_t *   p_input = (input_thread_t *)p_this;
 964     cdda_data_t *p_cdda = (cdda_data_t *)p_input->p_access_data;
 965
 966     dbg_print( (INPUT_DBG_CALL|INPUT_DBG_EXT), "" );
 967     ioctl_Close( p_cdda->p_cddev );
 968
 969     cdio_log_set_handler (uninit_log_handler);
 970
 971 #ifdef HAVE_LIBCDDB
 972     cddb_log_set_handler (uninit_log_handler);
 973     if (p_cdda->i_cddb_enabled)
 974       cddb_disc_destroy(p_cdda->cddb.disc);
 975 #endif
 976
 977     free( p_cdda );
 978     p_cdda_input = NULL;
 979 }