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

   1 /*****************************************************************************
   2  * info.c : CD digital audio input information routines
   3  *****************************************************************************
   4  * Copyright (C) 2004, 2005 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Rocky Bernstein <rocky@panix.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include "callback.h"      /* FIXME - reorganize callback.h, cdda.h better */
  28 #include "cdda.h"          /* private structures. Also #includes vlc things */
  29 #include <vlc_playlist.h>  /* Has to come *after* cdda.h */
  30
  31 #include <cdio/cdio.h>
  32 #include <cdio/cdtext.h>
  33 #include <cdio/logging.h>
  34 #include <cdio/cd_types.h>
  35 #include "info.h"
  36
  37 #ifdef HAVE_ERRNO_H
  38 #   include <errno.h>
  39 #endif
  40
  41 static char *CDDAFormatStr( const access_t *p_access, cdda_data_t *p_cdda,
  42                             const char format_str[], const char *psz_mrl,
  43                             track_t i_track);
  44
  45 static char *CDDAFormatMRL( const access_t *p_access, track_t i_track );
  46
  47 #ifdef HAVE_LIBCDDB
  48
  49 #define free_and_dup(var, val) \
  50   if (var) free(var);          \
  51   if (val) var=strdup(val);
  52
  53
  54 /* Saves CDDB information about CD-DA via libcddb. */
  55 static void
  56 GetCDDBInfo( access_t *p_access, cdda_data_t *p_cdda )
  57 {
  58     int i, i_matches;
  59     cddb_conn_t  *conn = cddb_new();
  60     const CdIo_t *p_cdio = p_cdda->p_cdio;
  61
  62     dbg_print( (INPUT_DBG_CALL), "" );
  63
  64 #ifdef FIXME_NOW
  65     cddb_log_set_handler (uninit_log_handler);
  66 #endif
  67
  68     if (!conn)
  69     {
  70         msg_Warn( p_access, "Unable to initialize libcddb" );
  71         goto cddb_destroy;
  72     }
  73
  74     cddb_set_email_address( conn,
  75                             config_GetPsz( p_access,
  76                                            MODULE_STRING "-cddb-email") );
  77     cddb_set_server_name( conn,
  78                           config_GetPsz( p_access,
  79                                          MODULE_STRING "-cddb-server") );
  80     cddb_set_server_port(conn,
  81                          config_GetInt( p_access,
  82                                         MODULE_STRING "-cddb-port") );
  83
  84   /* Set the location of the local CDDB cache directory.
  85      The default location of this directory is */
  86
  87     if (!config_GetInt( p_access, MODULE_STRING "-cddb-enable-cache" ))
  88         cddb_cache_disable(conn);
  89
  90     cddb_cache_set_dir(conn,
  91                      config_GetPsz( p_access,
  92                                     MODULE_STRING "-cddb-cachedir") );
  93
  94     cddb_set_timeout(conn,
  95                    config_GetInt( p_access, MODULE_STRING "-cddb-timeout") );
  96
  97
  98     if (config_GetInt( p_access, MODULE_STRING "-cddb-httpd" ) )
  99     {
 100         cddb_http_enable(conn);
 101     }
 102     else
 103     {
 104         cddb_http_disable(conn);
 105     }
 106
 107     p_cdda->cddb.disc = cddb_disc_new();
 108
 109     if (!p_cdda->cddb.disc)
 110     {
 111         msg_Err( p_access, "Unable to create CDDB disc structure." );
 112         goto cddb_end;
 113     }
 114
 115     for(i = 0; i < p_cdda->i_tracks; i++)
 116     {
 117         track_t i_track =  p_cdda->i_first_track + i;
 118         cddb_track_t *t = cddb_track_new();
 119         cddb_track_set_frame_offset(t,
 120                                     cdio_get_track_lba(p_cdio, i_track));
 121         cddb_disc_add_track(p_cdda->cddb.disc, t);
 122     }
 123
 124     cddb_disc_set_length(p_cdda->cddb.disc,
 125                          cdio_get_track_lba(p_cdio, CDIO_CDROM_LEADOUT_TRACK)
 126                          / CDIO_CD_FRAMES_PER_SEC);
 127
 128     if (!cddb_disc_calc_discid(p_cdda->cddb.disc))
 129     {
 130         msg_Err( p_access, "CDDB disc ID calculation failed" );
 131         goto cddb_destroy;
 132     }
 133
 134     i_matches = cddb_query(conn, p_cdda->cddb.disc);
 135
 136     if (i_matches > 0)
 137     {
 138         if (i_matches > 1)
 139              msg_Warn( p_access, "Found %d matches in CDDB. Using first one.",
 140                                  i_matches);
 141         cddb_read(conn, p_cdda->cddb.disc);
 142
 143         if (p_cdda->i_debug & INPUT_DBG_CDDB)
 144             cddb_disc_print(p_cdda->cddb.disc);
 145
 146     }
 147     else
 148     {
 149         msg_Warn( p_access, "CDDB error: %s", cddb_error_str(errno));
 150     }
 151
 152 cddb_destroy:
 153     cddb_destroy(conn);
 154
 155 cddb_end: ;
 156 }
 157 #endif /*HAVE_LIBCDDB*/
 158
 159 #define add_meta_val(VLC_META, VAL)                           \
 160   if ( p_cdda->p_meta && VAL) {                               \
 161     /*vlc_meta_Add( p_cdda->p_meta, VLC_META, VAL );*/        \
 162     dbg_print( INPUT_DBG_META, "field %s: %s\n",              \
 163             input_MetaTypeToLocalizedString(VLC_META), VAL ); \
 164   }                                                           \
 165
 166 #define add_cddb_meta(FIELD, VLC_META)                                  \
 167   add_meta_val(VLC_META, cddb_disc_get_##FIELD(p_cdda->cddb.disc));
 168
 169 #define add_cddb_meta_fmt(FIELD, FORMAT_SPEC, VLC_META)                 \
 170   {                                                                     \
 171     char psz_buf[100];                                                  \
 172     snprintf( psz_buf, sizeof(psz_buf)-1, FORMAT_SPEC,                  \
 173               cddb_disc_get_##FIELD(p_cdda->cddb.disc));                               \
 174     psz_buf[sizeof(psz_buf)-1] = '\0';                                  \
 175     add_meta_val(VLC_META, psz_buf);                                    \
 176   }
 177
 178 /* Adds a string-valued entry to the stream and media information if
 179    the string is not null or the null string.
 180  */
 181 #define add_info_str(CATEGORY, TITLE, FIELD)                      \
 182   if (FIELD && strlen(FIELD)) {                                   \
 183     input_Control( p_cdda->p_input, INPUT_ADD_INFO, CATEGORY,     \
 184                    _(TITLE), "%s", FIELD );                       \
 185   }
 186
 187 /* Adds a numeric-valued entry to the stream and media information
 188    if the number is not zero. */
 189 #define add_info_val(CATEGORY, TITLE, FMT, FIELD)                 \
 190   if (FIELD) {                                                    \
 191     input_Control( p_cdda->p_input, INPUT_ADD_INFO, CATEGORY,     \
 192                    _(TITLE), FMT, FIELD );                        \
 193   }
 194
 195 /* Adds a CDDB string-valued entry to the stream and media information
 196    under category "Disc" if the string is not null or the null string.
 197  */
 198 #define add_cddb_disc_info_str(TITLE, FIELD)                    \
 199   add_info_str("Disc", TITLE, cddb_disc_get_##FIELD(p_cdda->cddb.disc))
 200
 201 /* Adds a CDDB numeric-valued entry to the stream and media information
 202    under category "Disc" if the string is not null or the null string.
 203  */
 204 #define add_cddb_disc_info_val(TITLE, FMT, FIELD)               \
 205   add_info_val("Disc", TITLE, FMT, cddb_disc_get_##FIELD(p_cdda->cddb.disc))
 206
 207 /* Adds a CD-Text string-valued entry to the stream and media information
 208    under category "Disc" if the string is not null or the null string.
 209  */
 210 #define add_cdtext_info_str(CATEGORY, TITLE, INDEX, FIELD)              \
 211     add_info_str(CATEGORY, TITLE, p_cdda->p_cdtext[INDEX]->field[FIELD])
 212
 213 /* Adds a CD-Text string-valued entry to the stream and media information
 214    under category "Disc" if the string is not null or the null string.
 215  */
 216 #define add_cdtext_disc_info_str(TITLE, FIELD) \
 217   add_cdtext_info_str("Disc", TITLE, 0, FIELD)
 218
 219
 220 /*
 221   Saves Meta Information about the CD-DA.
 222
 223   Meta information used in "stream and media info" or in playlist
 224   info. The intialization of CD-Text or CDDB is done here though.
 225   Therefore, this should be called before CDDAMetaInfo is called.
 226
 227  */
 228 void
 229 CDDAMetaInfoInit( access_t *p_access )
 230 {
 231     cdda_data_t *p_cdda   = (cdda_data_t *) p_access->p_sys;
 232
 233     if ( ! p_cdda ) return;
 234
 235     dbg_print( (INPUT_DBG_CALL), "p_cdda->i_tracks %d",
 236                p_cdda->i_tracks );
 237
 238     p_cdda->psz_mcn = cdio_get_mcn(p_cdda->p_cdio);
 239 #if 0
 240     p_cdda->p_meta = vlc_meta_New();
 241 #endif
 242
 243 #ifdef HAVE_LIBCDDB
 244     if ( p_cdda->b_cddb_enabled )
 245     {
 246         GetCDDBInfo(p_access, p_cdda);
 247     }
 248
 249 #endif /*HAVE_LIBCDDB*/
 250
 251 #define TITLE_MAX 30
 252     {
 253         track_t i_track;
 254
 255         for( i_track = 0 ; i_track < p_cdda->i_tracks ; i_track++ )
 256         {
 257             p_cdda->p_cdtext[i_track] =
 258               cdio_get_cdtext(p_cdda->p_cdio, i_track);
 259         }
 260     }
 261 }
 262
 263 /*
 264  In the Control routine, we handle Meta Information requests and
 265  basically copy what was saved in CDDAMetaInfoInit.
 266
 267  If i_track is CDIO_INVALID_TRACK we are probably asking about the entire
 268  CD.
 269  */
 270 void
 271 CDDAMetaInfo( access_t *p_access, track_t i_track )
 272 {
 273     cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
 274     char *psz_meta_title = CDDAFormatMRL( p_access, i_track );
 275     char *psz_meta_artist = NULL;
 276
 277     if ( ! p_cdda ) return;
 278
 279     dbg_print( (INPUT_DBG_CALL), "i_track %d", i_track );
 280
 281 #ifdef HAVE_LIBCDDB
 282
 283     /* Set up for Meta and name for CDDB access. */
 284     if ( p_cdda->b_cddb_enabled &&  p_cdda->cddb.disc )
 285     {
 286         if( CDIO_INVALID_TRACK == i_track )
 287         {
 288
 289             psz_meta_title  = (char *)cddb_disc_get_title(p_cdda->cddb.disc);
 290             psz_meta_artist = (char *)cddb_disc_get_artist(p_cdda->cddb.disc);
 291             if ( cddb_disc_get_genre(p_cdda->cddb.disc) &&
 292                      strlen(cddb_disc_get_genre(p_cdda->cddb.disc)) )
 293                 add_cddb_meta(genre, vlc_meta_Genre);
 294             if ( 0 != cddb_disc_get_year(p_cdda->cddb.disc))
 295                 add_cddb_meta_fmt(year, "%d", vlc_meta_Date );
 296         }
 297         else
 298         {
 299           cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc, i_track-1);
 300           if (t != NULL )
 301           {
 302               if( cddb_track_get_title(t) != NULL && ! p_cdda->b_nav_mode )
 303               {
 304             add_meta_val( vlc_meta_Title, cddb_track_get_title(t) );
 305               }
 306               if( cddb_track_get_artist(t) != NULL )
 307               {
 308             add_meta_val( vlc_meta_Artist, cddb_track_get_artist(t) );
 309               }
 310           }
 311         }
 312     }
 313
 314 #endif /*HAVE_LIBCDDB*/
 315
 316 #define TITLE_MAX 30
 317     {
 318         track_t i = p_cdda->i_tracks;
 319         const int i_first_track = p_cdda->i_first_track;
 320         char psz_buffer[MSTRTIME_MAX_SIZE];
 321         unsigned int i_track_frames =
 322           cdio_get_track_lba(p_cdda->p_cdio, CDIO_CDROM_LEADOUT_TRACK);
 323
 324         mtime_t i_duration = i_track_frames / CDIO_CD_FRAMES_PER_SEC;
 325
 326         dbg_print( INPUT_DBG_META, "Duration %ld, tracks %d",
 327                    (long int) i_duration, p_cdda->i_tracks );
 328         input_Control( p_cdda->p_input, INPUT_ADD_INFO,
 329                        _("Disc"), _("Duration"), "%s",
 330                        secstotimestr( psz_buffer, i_duration ) );
 331
 332         if (p_cdda->psz_mcn) {
 333             input_Control( p_cdda->p_input, INPUT_ADD_INFO,
 334                            _("Disc"), _("Media Catalog Number (MCN)"), "%s",
 335                            p_cdda->psz_mcn );
 336
 337             input_Control( p_cdda->p_input, INPUT_ADD_INFO,
 338                            _("Disc"), _("Tracks"), "%d", p_cdda->i_tracks );
 339         }
 340
 341
 342 #ifdef HAVE_LIBCDDB
 343         if (p_cdda->b_cddb_enabled && p_cdda->cddb.disc)
 344         {
 345           add_cddb_disc_info_str("Artist (CDDB)", artist);
 346           if ( CDDB_CAT_INVALID != cddb_disc_get_category(p_cdda->cddb.disc) )
 347             add_info_str("Disc", "Category (CDDB)",
 348                          CDDB_CATEGORY[cddb_disc_get_category(p_cdda->cddb.disc)]);
 349           add_cddb_disc_info_val("Disc ID (CDDB)", "%x", discid);
 350           add_cddb_disc_info_str("Extended Data (CDDB)", ext_data);
 351           add_cddb_disc_info_str("Genre (CDDB)",  genre);
 352           add_cddb_disc_info_str("Title (CDDB)",  title);
 353           if ( 0 != cddb_disc_get_year(p_cdda->cddb.disc) )
 354             add_cddb_disc_info_val("Year (CDDB)", "%d", year);
 355
 356         }
 357 #endif /*HAVE_LIBCDDB*/
 358
 359         if (p_cdda->p_cdtext[0])
 360         {
 361             char *psz_field;
 362
 363             add_cdtext_disc_info_str("Arranger (CD-Text)",    CDTEXT_ARRANGER);
 364             add_cdtext_disc_info_str("Composer (CD-Text)",    CDTEXT_COMPOSER);
 365             add_cdtext_disc_info_str("Disc ID (CD-Text)",     CDTEXT_DISCID);
 366             add_cdtext_disc_info_str("Genre (CD-Text)",       CDTEXT_GENRE);
 367             add_cdtext_disc_info_str("Message (CD-Text)",     CDTEXT_MESSAGE);
 368             add_cdtext_disc_info_str("Performer (CD-Text)",   CDTEXT_PERFORMER);
 369             add_cdtext_disc_info_str("Songwriter (CD-Text)",  CDTEXT_SONGWRITER);
 370             add_cdtext_disc_info_str("Title (CD-Text)",       CDTEXT_TITLE);
 371
 372             psz_field = p_cdda->p_cdtext[0]->field[CDTEXT_TITLE];
 373             if (psz_field && strlen(psz_field)) {
 374               psz_meta_title = psz_field;
 375             }
 376             psz_field = p_cdda->p_cdtext[0]->field[CDTEXT_PERFORMER];
 377             if (psz_field && strlen(psz_field)) {
 378               psz_meta_artist = psz_field;
 379             }
 380
 381         }
 382
 383         for( i = 0 ; i < p_cdda->i_tracks ; i++ )
 384         {
 385           char psz_track[TITLE_MAX];
 386           const track_t i_track = i_first_track + i;
 387           unsigned int i_track_frames =
 388             cdio_get_track_lsn(p_cdda->p_cdio, i_track+1) -
 389             cdio_get_track_lsn(p_cdda->p_cdio, i_track);
 390
 391           mtime_t i_duration = i_track_frames / CDIO_CD_FRAMES_PER_SEC;
 392           char *psz_mrl = CDDAFormatMRL( p_access, i_track );
 393
 394           snprintf(psz_track, TITLE_MAX, "%s %02d", _("Track"), i_track);
 395
 396           input_Control( p_cdda->p_input, INPUT_ADD_INFO, psz_track,
 397                          _("Duration"), "%s",
 398                          secstotimestr( psz_buffer, i_duration ) );
 399
 400           input_Control( p_cdda->p_input, INPUT_ADD_INFO, psz_track,
 401                          _("MRL"), "%s", psz_mrl );
 402           free(psz_mrl);
 403
 404           if (p_cdda->p_cdtext[i_track])
 405             {
 406               add_cdtext_info_str( psz_track, "Arranger (CD-Text)",
 407                                    i_track, CDTEXT_ARRANGER);
 408               add_cdtext_info_str( psz_track, "Composer (CD-Text)",
 409                                    i_track, CDTEXT_COMPOSER);
 410               add_cdtext_info_str( psz_track, "Disc ID (CD-Text)",
 411                                    i_track, CDTEXT_DISCID);
 412               add_cdtext_info_str( psz_track, "Genre (CD-Text)",
 413                                    i_track, CDTEXT_GENRE);
 414               add_cdtext_info_str( psz_track, "Message (CD-Text)",
 415                                    i_track, CDTEXT_MESSAGE);
 416               add_cdtext_info_str( psz_track, "Performer (CD-Text)",
 417                                    i_track, CDTEXT_PERFORMER);
 418               add_cdtext_info_str( psz_track, "Songwriter (CD-Text)",
 419                                    i_track, CDTEXT_SONGWRITER);
 420               add_cdtext_info_str( psz_track, "Title (CD-Text)",
 421                                    i_track, CDTEXT_TITLE);
 422             }
 423
 424 #ifdef HAVE_LIBCDDB
 425           if (p_cdda->b_cddb_enabled)
 426             {
 427               cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc, i);
 428               if (t != NULL)
 429                 {
 430                   add_info_str(psz_track, "Artist (CDDB)",
 431                                cddb_track_get_artist(t));
 432                   add_info_str(psz_track, "Title (CDDB)",
 433                                cddb_track_get_title(t));
 434                   add_info_str(psz_track, "Extended Data (CDDB)",
 435                                cddb_track_get_ext_data(t));
 436                 }
 437             }
 438 #endif /*HAVE_LIBCDDB*/
 439         }
 440
 441         /* Above we should have set psz_meta_title and psz_meta_artist
 442            to CDDB or CD-Text values or the default value depending on
 443            availablity and user preferences.
 444
 445            So now add the title and artist to VLC's meta, and the name
 446            as shown in the status bar and playlist entry.
 447
 448            For playlist mode, the meta title is what's seen at the
 449            bottom and in the playlist. For nav-mode playing, it is
 450            done by input_control. I don't understand why they do
 451            different things. In either case, we may have customized to
 452            put in the track name.
 453          */
 454         if ( CDIO_INVALID_TRACK != i_track )
 455         {
 456             char *psz_name = CDDAFormatTitle( p_access, i_track ) ;
 457             if ( !p_cdda->b_nav_mode ) {
 458                 add_meta_val( vlc_meta_Title, psz_name );
 459             } else
 460             {
 461                 input_Control( p_cdda->p_input, INPUT_SET_NAME, psz_name );
 462                 free(psz_name);
 463             }
 464             if (psz_meta_artist)
 465               add_meta_val( vlc_meta_Artist, psz_meta_artist );
 466         }
 467
 468     }
 469 }
 470
 471 #define add_format_str_info(val)                         \
 472   {                                                      \
 473     const char *str = val;                               \
 474     unsigned int len;                                    \
 475     if (val != NULL) {                                   \
 476       len=strlen(str);                                   \
 477       if (len != 0) {                                    \
 478         strncat(tp, str, TEMP_STR_LEN-(tp-temp_str));    \
 479         tp += len;                                       \
 480       }                                                  \
 481       saw_control_prefix = false;                        \
 482     }                                                    \
 483   }
 484
 485 #define add_format_num_info(val, fmt)                    \
 486   {                                                      \
 487     char num_str[10];                                    \
 488     unsigned int len;                                    \
 489     sprintf(num_str, fmt, val);                          \
 490     len=strlen(num_str);                                 \
 491     if (len != 0) {                                      \
 492       strncat(tp, num_str, TEMP_STR_LEN-(tp-temp_str));  \
 493       tp += len;                                         \
 494     }                                                    \
 495     saw_control_prefix = false;                          \
 496   }
 497
 498 static inline bool
 499 want_cddb_info(
 500 cdda_data_t *p_cdda, char *psz_cdtext)
 501 {
 502   /* We either don't have CD-Text info, or we do but we prefer to get CDDB
 503      which means CDDB has been enabled and we were able to retrieve the info.*/
 504 #ifdef HAVE_LIBCDDB
 505   return !psz_cdtext ||
 506     (!p_cdda->b_cdtext_prefer && p_cdda->b_cddb_enabled && p_cdda->cddb.disc);
 507 #else
 508   return false;
 509 #endif
 510 }
 511
 512
 513 /*!
 514    Take a format string and expand escape sequences, that is sequences that
 515    begin with %, with information from the current CD.
 516    The expanded string is returned. Here is a list of escape sequences:
 517
 518    %a : The album artist **
 519    %A : The album information **
 520    %C : Category **
 521    %e : The extended track data
 522    %I : CDDB disk ID **
 523    %G : Genre **
 524    %M : The current MRL
 525    %m : The CD-DA Media Catalog Number (MCN)
 526    %n : The number of tracks on the CD
 527    %p : The artist/performer/composer in the track **
 528    %T : The track number **
 529    %s : Number of seconds in this track, or seconds in CD if invalid track
 530    %S : Number of seconds on the CD
 531    %t : The track name or MRL if no name
 532    %Y : The year 19xx or 20xx **
 533    %% : a %
 534 */
 535 char *
 536 CDDAFormatStr( const access_t *p_access, cdda_data_t *p_cdda,
 537                const char format_str[], const char *psz_mrl, track_t i_track)
 538 {
 539 #define TEMP_STR_SIZE 256
 540 #define TEMP_STR_LEN (TEMP_STR_SIZE-1)
 541     static char temp_str[TEMP_STR_SIZE];
 542     size_t i;
 543     char * tp = temp_str;
 544     vlc_bool_t saw_control_prefix = false;
 545     size_t format_len = strlen(format_str);
 546
 547     memset(temp_str, 0, TEMP_STR_SIZE);
 548
 549     for (i=0; i<format_len; i++)
 550     {
 551         char *psz = NULL;
 552
 553         if (!saw_control_prefix && format_str[i] != '%')
 554         {
 555             *tp++ = format_str[i];
 556             saw_control_prefix = false;
 557             continue;
 558         }
 559
 560         switch(format_str[i])
 561         {
 562             case '%':
 563               if (saw_control_prefix)
 564               {
 565                   *tp++ = '%';
 566               }
 567               saw_control_prefix = !saw_control_prefix;
 568               break;
 569 #ifdef HAVE_LIBCDDB
 570             case 'a':
 571                 if (p_cdda->p_cdtext[0]
 572                     && p_cdda->p_cdtext[0]->field[CDTEXT_PERFORMER])
 573                   psz = p_cdda->p_cdtext[0]->field[CDTEXT_PERFORMER];
 574                 if (want_cddb_info(p_cdda, psz))
 575                   psz = (char *)cddb_disc_get_artist(p_cdda->cddb.disc);
 576                 goto format_str;
 577             case 'A':
 578                 if (p_cdda->p_cdtext[0]
 579                     && p_cdda->p_cdtext[0]->field[CDTEXT_TITLE])
 580                   psz = p_cdda->p_cdtext[0]->field[CDTEXT_TITLE];
 581                 if (want_cddb_info(p_cdda, psz))
 582                   psz =  (char *)cddb_disc_get_title(p_cdda->cddb.disc);
 583                 goto format_str;
 584             case 'C':
 585                 if (!p_cdda->b_cddb_enabled) goto not_special;
 586                 if (p_cdda->cddb.disc)
 587                     add_format_str_info(CDDB_CATEGORY[cddb_disc_get_category(p_cdda->cddb.disc)]);
 588                 break;
 589             case 'G':
 590                 if (p_cdda->p_cdtext[0]
 591                     && p_cdda->p_cdtext[0]->field[CDTEXT_GENRE])
 592                   psz = p_cdda->p_cdtext[0]->field[CDTEXT_GENRE];
 593                 if (want_cddb_info(p_cdda, psz))
 594                   psz = (char *)cddb_disc_get_genre(p_cdda->cddb.disc);
 595                 goto format_str;
 596             case 'I':
 597                 if (p_cdda->p_cdtext[0]
 598                     && p_cdda->p_cdtext[0]->field[CDTEXT_DISCID])
 599                   psz = p_cdda->p_cdtext[0]->field[CDTEXT_DISCID];
 600                 if (want_cddb_info(p_cdda, psz)) {
 601                      add_format_num_info(cddb_disc_get_discid(p_cdda->cddb.disc), "%x");
 602                 } else if (psz)
 603                      add_format_str_info(psz);
 604                 break;
 605             case 'Y':
 606                 if (!p_cdda->b_cddb_enabled) goto not_special;
 607                 if (p_cdda->cddb.disc)
 608                     add_format_num_info(cddb_disc_get_year(p_cdda->cddb.disc),
 609                                         "%5d");
 610                 break;
 611             case 't':
 612                 if ( CDIO_INVALID_TRACK == i_track ) break;
 613                 if (p_cdda && p_cdda->b_cddb_enabled && p_cdda->cddb.disc)
 614                 {
 615                     cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
 616                                                         i_track-1);
 617                     if (t != NULL && cddb_track_get_title(t) != NULL) {
 618                       add_format_str_info(cddb_track_get_title(t));
 619                     } else {
 620                       add_format_str_info(psz_mrl);
 621                     }
 622                 } else {
 623                   if (p_cdda->p_cdtext[i_track]
 624                       && p_cdda->p_cdtext[i_track]->field[CDTEXT_TITLE]) {
 625                     add_format_str_info(p_cdda->p_cdtext[i_track]->field[CDTEXT_TITLE]);
 626
 627                   } else
 628                     add_format_str_info(psz_mrl);
 629                 }
 630                 break;
 631             case 'p':
 632                 if ( CDIO_INVALID_TRACK == i_track ) break;
 633                 if (p_cdda->p_cdtext[i_track]
 634                     && p_cdda->p_cdtext[i_track]->field[CDTEXT_PERFORMER])
 635                   psz = p_cdda->p_cdtext[i_track]->field[CDTEXT_PERFORMER];
 636                 if (want_cddb_info(p_cdda, psz))
 637                   {
 638                     cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
 639                                                         i_track-1);
 640                     if (t != NULL && cddb_track_get_artist(t) != NULL)
 641                       psz = (char *)cddb_track_get_artist(t);
 642                   }
 643                 goto format_str;
 644             case 'e':
 645                 if ( CDIO_INVALID_TRACK == i_track ) break;
 646                 if (p_cdda->p_cdtext[i_track]
 647                     && p_cdda->p_cdtext[i_track]->field[CDTEXT_MESSAGE])
 648                   psz = p_cdda->p_cdtext[i_track]->field[CDTEXT_MESSAGE];
 649                 if (want_cddb_info(p_cdda, psz))
 650                 {
 651                     cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
 652                                                         i_track-1);
 653                     if (t != NULL && cddb_track_get_ext_data(t) != NULL)
 654                         psz = (char *)cddb_track_get_ext_data(t);
 655                 }
 656                 goto format_str;
 657                 break;
 658 #else
 659             case 'a':
 660                 if (p_cdda->p_cdtext[0]
 661                     && p_cdda->p_cdtext[0]->field[CDTEXT_PERFORMER])
 662                     psz = p_cdda->p_cdtext[0]->field[CDTEXT_PERFORMER];
 663                 goto format_str;
 664             case 'A':
 665                 if (p_cdda->p_cdtext[0]
 666                     && p_cdda->p_cdtext[0]->field[CDTEXT_TITLE])
 667                     psz = p_cdda->p_cdtext[0]->field[CDTEXT_TITLE];
 668                 goto format_str;
 669             case 'G':
 670                 if (p_cdda->p_cdtext[0]
 671                     && p_cdda->p_cdtext[0]->field[CDTEXT_GENRE])
 672                   psz = p_cdda->p_cdtext[0]->field[CDTEXT_GENRE];
 673                 goto format_str;
 674             case 'I':
 675                 if (p_cdda->p_cdtext[0]
 676                     && p_cdda->p_cdtext[0]->field[CDTEXT_DISCID])
 677                   add_format_str_info(p_cdda->p_cdtext[0]->field[CDTEXT_DISCID]);
 678                 break;
 679             case 'p':
 680                 if ( CDIO_INVALID_TRACK == i_track ) break;
 681                 if (p_cdda->p_cdtext[i_track]
 682                     && p_cdda->p_cdtext[i_track]->field[CDTEXT_PERFORMER])
 683                   psz = p_cdda->p_cdtext[i_track]->field[CDTEXT_PERFORMER];
 684                 goto format_str;
 685             case 't':
 686                 if ( CDIO_INVALID_TRACK == i_track ) break;
 687                 if (p_cdda->p_cdtext[i_track]
 688                     && p_cdda->p_cdtext[i_track]->field[CDTEXT_TITLE])
 689                     psz = p_cdda->p_cdtext[i_track]->field[CDTEXT_TITLE];
 690                 else
 691                     psz = psz_mrl;
 692                 goto format_str;
 693             case 'e':
 694                 if ( CDIO_INVALID_TRACK == i_track ) break;
 695                 if (p_cdda->p_cdtext[i_track]
 696                     && p_cdda->p_cdtext[i_track]->field[CDTEXT_MESSAGE])
 697                   psz = p_cdda->p_cdtext[i_track]->field[CDTEXT_MESSAGE];
 698                 goto format_str;
 699                 break;
 700 #endif /*HAVE_LIBCDDB*/
 701
 702             case 's':
 703                 if ( CDIO_INVALID_TRACK != i_track )
 704                 {
 705                     char psz_buffer[MSTRTIME_MAX_SIZE];
 706                     unsigned int i_track_frames =
 707                       cdio_get_track_sec_count(p_cdda->p_cdio, i_track);
 708                     mtime_t i_duration =
 709                       i_track_frames / CDIO_CD_FRAMES_PER_SEC;
 710                     add_format_str_info( secstotimestr( psz_buffer,
 711                                                         i_duration ) );
 712                     break;
 713                 }
 714
 715                 /* Fall through to disc duration if CDIO_INVALID_TRACK  */
 716             case 'S':
 717                 {
 718                     char psz_buffer[MSTRTIME_MAX_SIZE];
 719                     unsigned int i_track_frames =
 720                       cdio_get_track_lba(p_cdda->p_cdio,
 721                                          CDIO_CDROM_LEADOUT_TRACK);
 722                     mtime_t i_duration =
 723                       i_track_frames / CDIO_CD_FRAMES_PER_SEC;
 724                     add_format_str_info( secstotimestr( psz_buffer,
 725                                                         i_duration ) );
 726                     break;
 727                 }
 728
 729             case 'M':
 730               add_format_str_info(psz_mrl);
 731               break;
 732
 733             case 'm':
 734               add_format_str_info(p_cdda->psz_mcn);
 735               break;
 736
 737             case 'n':
 738               add_format_num_info(p_cdda->i_tracks, "%d");
 739               break;
 740
 741             case 'T':
 742               add_format_num_info(i_track, "%02d");
 743               break;
 744             format_str:
 745               if (psz)
 746                 add_format_str_info(psz);
 747               break;
 748 #ifdef HAVE_LIBCDDB
 749             not_special:
 750 #endif
 751             default:
 752                 *tp++ = '%';
 753                 *tp++ = format_str[i];
 754                 saw_control_prefix = false;
 755         }
 756     }
 757     return strdup(temp_str);
 758 }
 759
 760 /* Return a MRL for the given track. The caller must free the
 761    allocated string. */
 762 static char *
 763 CDDAFormatMRL( const access_t *p_access, track_t i_track )
 764 {
 765     cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
 766     const unsigned int psz_mrl_max = strlen(CDDA_MRL_PREFIX)
 767       + strlen(p_cdda->psz_source) +
 768       + strlen("@T") + strlen("100") + 1;
 769     char *psz_mrl = calloc( 1, psz_mrl_max );
 770
 771     if (CDIO_INVALID_TRACK == i_track)
 772       snprintf(psz_mrl, psz_mrl_max, "%s%s",
 773                CDDA_MRL_PREFIX, p_cdda->psz_source);
 774     else
 775       snprintf(psz_mrl, psz_mrl_max, "%s%s@T%u",
 776                CDDA_MRL_PREFIX, p_cdda->psz_source, i_track);
 777     return psz_mrl;
 778 }
 779
 780
 781 /* Return a title string as specified by the titel format string for the
 782    given track. The caller must free the allocated string. */
 783 char *
 784 CDDAFormatTitle( const access_t *p_access, track_t i_track )
 785 {
 786
 787     const char *config_varname = MODULE_STRING "-title-format";
 788     cdda_data_t *p_cdda = (cdda_data_t *) p_access->p_sys;
 789     char *psz_mrl = CDDAFormatMRL( p_access, i_track );
 790
 791     if( psz_mrl )
 792     {
 793         char *psz_name;
 794 #ifdef HAVE_LIBCDDB
 795         if (p_cdda->b_cddb_enabled)
 796         {
 797             config_varname = MODULE_STRING "-cddb-title-format";
 798         }
 799 #endif /*HAVE_LIBCDDB*/
 800         psz_name =
 801           CDDAFormatStr( p_access, p_cdda,
 802                          config_GetPsz( p_access, config_varname ),
 803                          psz_mrl, i_track );
 804         free(psz_mrl);
 805         return psz_name;
 806     }
 807     return(NULL);
 808 }
 809
 810 /* Adds a string-valued entry to the playlist information under "Track"
 811    if the string is not null or the null string.
 812  */
 813 #define add_playlist_track_info_str(TITLE, FIELD)                        \
 814     if (FIELD && strlen(FIELD))                                          \
 815     {                                                                    \
 816         input_ItemAddInfo( &p_item->input, _("Track"), _(TITLE),    \
 817                               "%s", FIELD);                              \
 818     }
 819
 820 static playlist_item_t *
 821 CDDACreatePlaylistItem( const access_t *p_access, cdda_data_t *p_cdda,
 822                         playlist_t *p_playlist, playlist_item_t *p_item,
 823                         track_t i_track )
 824 {
 825     unsigned int i_track_frames =
 826         cdio_get_track_lsn(p_cdda->p_cdio, i_track+1) -
 827         cdio_get_track_lsn(p_cdda->p_cdio, i_track);
 828     mtime_t i_mduration = i_track_frames * (CLOCK_FREQ / CDIO_CD_FRAMES_PER_SEC) ;
 829     char *psz_title = NULL;
 830     char *psz_mrl   = NULL;
 831
 832     playlist_item_t *p_child = NULL;
 833
 834     if( !p_item ) return NULL;
 835
 836     psz_title = CDDAFormatTitle( p_access, i_track ) ;
 837     psz_mrl = CDDAFormatMRL( p_access, i_track  ) ;
 838
 839     dbg_print( INPUT_DBG_META, "mrl: %s, title: %s, duration, %ld",
 840                psz_mrl, psz_title, (long int) i_mduration / 1000000 );
 841
 842     p_child = playlist_ItemNew( p_playlist, psz_mrl, psz_title );
 843     input_item_SetDuration( input_GetItem( p_child->p_input ),
 844             (mtime_t) i_mduration );
 845     free(psz_mrl);
 846     free(psz_title);
 847
 848     if( !p_child ) return NULL;
 849     return p_child;
 850 }
 851
 852 int CDDAAddMetaToItem( access_t *p_access, cdda_data_t *p_cdda,
 853                        playlist_item_t *p_item, int i_track,
 854                        vlc_bool_t b_single )
 855 {
 856 #if 0
 857     add_playlist_track_info_str("Source",  p_cdda->psz_source);
 858     input_ItemAddInfo( &p_item->input, _("Track"), _("Track Number"),
 859                            "%d", i_track );
 860
 861     if (p_cdda->p_cdtext[i_track])
 862     {
 863         const cdtext_t *p = p_cdda->p_cdtext[i_track];
 864         add_playlist_track_info_str("Arranger (CD-Text)",
 865                                     p->field[CDTEXT_ARRANGER]);
 866         add_playlist_track_info_str("Composer (CD-Text)",
 867                                     p->field[CDTEXT_COMPOSER]);
 868         add_playlist_track_info_str("Genre (CD-Text)",
 869                                     p->field[CDTEXT_GENRE]);
 870         add_playlist_track_info_str("Message (CD-Text)",
 871                                     p->field[CDTEXT_MESSAGE]);
 872         add_playlist_track_info_str("Performer (CD-Text)",
 873                                     p->field[CDTEXT_PERFORMER]);
 874         add_playlist_track_info_str("Songwriter (CD-Text)",
 875                                     p->field[CDTEXT_SONGWRITER]);
 876         add_playlist_track_info_str("Title (CD-Text)",
 877                                     p->field[CDTEXT_TITLE]);
 878     }
 879
 880 #ifdef HAVE_LIBCDDB
 881     if (p_cdda->b_cddb_enabled)
 882     {
 883         cddb_track_t *t=cddb_disc_get_track(p_cdda->cddb.disc,
 884                                             i_track-p_cdda->i_first_track);
 885
 886         if (t)
 887         {
 888             if (cddb_track_get_artist(t))
 889                 add_playlist_track_info_str("Artist (CDDB)",
 890                                              cddb_track_get_artist(t));
 891             if (cddb_track_get_title(t))
 892                 add_playlist_track_info_str("Title (CDDB)",
 893                                             cddb_track_get_title(t));
 894             if (cddb_track_get_ext_data(t))
 895                 add_playlist_track_info_str("Extended information (CDDB)",
 896                                             cddb_track_get_ext_data(t));
 897         }
 898     }
 899 #endif /*HAVE_LIBCDDB*/
 900 #endif
 901     return VLC_SUCCESS;
 902 }
 903
 904 /*
 905    Fixes up playlist.
 906 */
 907 int
 908 CDDAFixupPlaylist( access_t *p_access, cdda_data_t *p_cdda,
 909                    vlc_bool_t b_single_track )
 910 {
 911     int i;
 912     playlist_t * p_playlist = NULL;
 913     const track_t i_first_track = p_cdda->i_first_track;
 914     playlist_item_t *p_item = NULL;
 915     vlc_bool_t b_play = VLC_FALSE;
 916     track_t    i_track;
 917
 918 #ifdef HAVE_LIBCDDB
 919     p_cdda->b_cddb_enabled =
 920         config_GetInt( p_access, MODULE_STRING "-cddb-enabled" );
 921     if( b_single_track && !p_cdda->b_cddb_enabled )
 922         return VLC_SUCCESS;
 923 #else
 924     if( b_single_track )
 925         return VLC_SUCCESS;
 926 #endif
 927
 928     if (! p_cdda->b_nav_mode ) {
 929         p_playlist = pl_Yield( p_access );
 930     }
 931
 932     if( b_single_track || p_cdda->b_nav_mode ) {
 933         i_track = p_cdda->i_track;
 934     }
 935     else
 936     {
 937         i_track = CDIO_INVALID_TRACK;
 938     }
 939     CDDAMetaInfoInit( p_access );
 940     CDDAMetaInfo( p_access, p_cdda->i_track );
 941
 942     if( p_playlist )
 943     {
 944         input_thread_t *p_input = (input_thread_t*)vlc_object_find( p_access, VLC_OBJECT_INPUT, FIND_PARENT );
 945         if( p_input )
 946         {
 947             p_item = playlist_ItemGetByInput( p_playlist, input_GetItem(p_input), VLC_FALSE );
 948
 949             if( p_item == p_playlist->status.p_item && !b_single_track )
 950                 b_play = VLC_TRUE;
 951             else
 952                 b_play = VLC_FALSE;
 953             vlc_object_release( p_input );
 954         }
 955     }
 956
 957     if( b_single_track && !p_cdda->b_nav_mode )
 958     {
 959         /*May fill out more information when the playlist user interface becomes
 960            more mature.
 961          */
 962         track_t i_track = p_cdda->i_track;
 963         unsigned int i_track_frames =
 964           cdio_get_track_sec_count(p_cdda->p_cdio, i_track);
 965
 966         input_title_t *t = p_cdda->p_title[0] = //i_track-i_first_track] =
 967         vlc_input_title_New();
 968
 969         asprintf( &t->psz_name, _("Track %i"), i_track );
 970         t->i_size = i_track_frames * (int64_t) CDIO_CD_FRAMESIZE_RAW;
 971
 972         t->i_length = I64C(1000000) * t->i_size / CDDA_FREQUENCY_SAMPLE / 4;
 973
 974         if( p_item )
 975         {
 976             CDDAAddMetaToItem( p_access, p_cdda, p_item, i_track, VLC_FALSE );
 977             input_item_SetDuration( p_item->p_input, (mtime_t) i_track_frames
 978               * (CLOCK_FREQ / CDIO_CD_FRAMES_PER_SEC) );
 979             input_item_SetURI( p_item->p_input,
 980                     CDDAFormatMRL( p_access, i_track ) );
 981         }
 982
 983         p_cdda->i_titles = 1;
 984         p_access->info.i_update = INPUT_UPDATE_TITLE;
 985     }
 986     else
 987     {
 988         input_title_t *t;
 989
 990         if ( !p_cdda->b_nav_mode )
 991           playlist_ItemToNode( p_playlist, p_item, VLC_FALSE );
 992
 993         for( i = 0 ; i < p_cdda->i_tracks ; i++ )
 994         {
 995             playlist_item_t *p_child;
 996             const track_t i_track = i_first_track + i;
 997             unsigned int i_track_frames =
 998               cdio_get_track_sec_count(p_cdda->p_cdio, i_track);
 999
1000             t = p_cdda->p_title[i] = vlc_input_title_New();
1001
1002             asprintf( &t->psz_name, _("Track %i"), i_track );
1003             t->i_size = i_track_frames * (int64_t) CDIO_CD_FRAMESIZE_RAW;
1004
1005             t->i_length = I64C(1000000) * t->i_size
1006               / CDDA_FREQUENCY_SAMPLE / 4;
1007
1008             if ( ! p_cdda->b_nav_mode ) {
1009               p_child = CDDACreatePlaylistItem( p_access, p_cdda, p_playlist,
1010                                                 p_item,
1011                                                 i_track );
1012               CDDAAddMetaToItem( p_access, p_cdda, p_child, i_track,
1013                                  VLC_TRUE );
1014             }
1015         }
1016
1017         p_cdda->i_titles = p_cdda->i_tracks;
1018         p_access->info.i_update |= INPUT_UPDATE_TITLE|INPUT_UPDATE_SIZE;
1019         if( p_item )
1020         {
1021             input_item_SetDuration( p_item->p_input, (mtime_t) p_access->info.i_size
1022                     * (CLOCK_FREQ / CDIO_CD_FRAMES_PER_SEC) );
1023             input_item_SetURI( p_item->p_input,
1024                     CDDAFormatMRL( p_access, p_cdda->i_track ) );
1025         }
1026     }
1027
1028
1029     if( b_play )
1030     {
1031         playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, VLC_TRUE,
1032                           p_playlist->status.p_item, NULL );
1033     }
1034
1035     if (p_playlist) vlc_object_release( p_playlist );
1036     return VLC_SUCCESS;
1037 }
1038
1039
1040 /*
1041  * Local variables:
1042  *  mode: C
1043  *  style: gnu
1044  * End:
1045  */