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