modules/access/cdda.c

   1 /*****************************************************************************
   2  * cdda.c : CD digital audio input module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2000, 2003-2006, 2008-2009 VLC authors and VideoLAN
   5  *
   6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   7  *          Gildas Bazin <gbazin@netcourrier.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /**
  25  * Todo:
  26  *   - Improve CDDB support (non-blocking, ...)
  27  *   - Fix tracknumber in MRL
  28  */
  29
  30 /*****************************************************************************
  31  * Preamble
  32  *****************************************************************************/
  33
  34 #ifdef HAVE_CONFIG_H
  35 # include "config.h"
  36 #endif
  37
  38 #include <assert.h>
  39 #include <math.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43
  44 #include <vlc_common.h>
  45 #include <vlc_demux.h>
  46 #include <vlc_plugin.h>
  47 #include <vlc_input_item.h>
  48 #include <vlc_access.h>
  49 #include <vlc_meta.h>
  50 #include <vlc_charset.h> /* ToLocaleDup */
  51 #include <vlc_url.h>
  52 #include <vlc_strings.h>
  53 #include <vlc_memstream.h>
  54 #ifdef HAVE_GCRYPT
  55 # include <gcrypt.h>
  56 # include <vlc_gcrypt.h>
  57 #endif
  58
  59 #include "disc_helper.h"
  60 #include "vcd/cdrom.h"  /* For CDDA_DATA_SIZE */
  61 #include "../misc/webservices/musicbrainz.h"
  62
  63
  64 #ifdef HAVE_LIBCDDB
  65  #include <cddb/cddb.h>
  66  #include <errno.h>
  67 #endif
  68
  69 static vcddev_t *DiscOpen(vlc_object_t *obj, const char *location,
  70                          const char *path, unsigned *restrict trackp)
  71 {
  72     char *devpath;
  73
  74     *trackp = var_InheritInteger(obj, "cdda-track");
  75
  76     if (path != NULL)
  77         devpath = ToLocaleDup(path);
  78     else if (location[0] != '\0')
  79     {
  80 #if (DIR_SEP_CHAR == '/')
  81         char *dec = vlc_uri_decode_duplicate(location);
  82         if (dec == NULL)
  83             return NULL;
  84
  85         /* GNOME CDDA syntax */
  86         const char *sl = strrchr(dec, '/');
  87         if (sl != NULL)
  88         {
  89             if (sscanf(sl, "/Track %2u", trackp) == 1)
  90                 dec[sl - dec] = '\0';
  91             else
  92                 *trackp = 0;
  93         }
  94
  95         if (unlikely(asprintf(&devpath, "/dev/%s", dec) == -1))
  96             devpath = NULL;
  97         free(dec);
  98 #else
  99         (void) location;
 100         return NULL;
 101 #endif
 102     }
 103     else
 104         devpath = var_InheritString(obj, "cd-audio");
 105
 106     if (devpath == NULL)
 107         return NULL;
 108
 109 #if defined (_WIN32) || defined (__OS2__)
 110     /* Trim backslash after drive letter */
 111     if (devpath[0] != '\0' && !strcmp(&devpath[1], ":" DIR_SEP))
 112         devpath[2] = '\0';
 113 #endif
 114
 115     if (DiscProbeMacOSPermission(obj, devpath) != VLC_SUCCESS) {
 116         free(devpath);
 117         return NULL;
 118     }
 119
 120     /* Open CDDA */
 121     vcddev_t *dev = ioctl_Open(obj, devpath);
 122     if (dev == NULL)
 123         msg_Warn(obj, "cannot open disc %s", devpath);
 124     free(devpath);
 125
 126     return dev;
 127 }
 128
 129 /* how many blocks Demux() will read in each iteration */
 130 #define CDDA_BLOCKS_ONCE 20
 131
 132 typedef struct
 133 {
 134     vcddev_t    *vcddev;                            /* vcd device descriptor */
 135     es_out_id_t *es;
 136     date_t       pts;
 137
 138     unsigned start; /**< Track first sector */
 139     unsigned length; /**< Track total sectors */
 140     unsigned position; /**< Current offset within track sectors */
 141 } demux_sys_t;
 142
 143 static int Demux(demux_t *demux)
 144 {
 145     demux_sys_t *sys = demux->p_sys;
 146     unsigned count = CDDA_BLOCKS_ONCE;
 147
 148     if (sys->position >= sys->length)
 149         return VLC_DEMUXER_EOF;
 150
 151     if (sys->position + count >= sys->length)
 152         count = sys->length - sys->position;
 153
 154     block_t *block = block_Alloc(count * CDDA_DATA_SIZE);
 155     if (unlikely(block == NULL))
 156         return VLC_DEMUXER_EOF;
 157
 158     if (ioctl_ReadSectors(VLC_OBJECT(demux), sys->vcddev,
 159                           sys->start + sys->position,
 160                           block->p_buffer, count, CDDA_TYPE) < 0)
 161     {
 162         msg_Err(demux, "cannot read sector %u", sys->position);
 163         block_Release(block);
 164
 165         /* Skip potentially bad sector */
 166         sys->position++;
 167         return VLC_DEMUXER_SUCCESS;
 168     }
 169
 170     sys->position += count;
 171
 172     block->i_nb_samples = block->i_buffer / 4;
 173     block->i_dts = block->i_pts = date_Get(&sys->pts);
 174     date_Increment(&sys->pts, block->i_nb_samples);
 175
 176     es_out_Send(demux->out, sys->es, block);
 177     es_out_SetPCR(demux->out, date_Get(&sys->pts));
 178     return VLC_DEMUXER_SUCCESS;
 179 }
 180
 181 static int DemuxControl(demux_t *demux, int query, va_list args)
 182 {
 183     demux_sys_t *sys = demux->p_sys;
 184
 185     /* One sector is 40000/3 µs */
 186     static_assert (CDDA_DATA_SIZE * CLOCK_FREQ * 3 ==
 187                    4 * 44100 * INT64_C(40000), "Wrong time/sector ratio");
 188
 189     switch (query)
 190     {
 191         case DEMUX_CAN_SEEK:
 192         case DEMUX_CAN_PAUSE:
 193         case DEMUX_CAN_CONTROL_PACE:
 194             *va_arg(args, bool*) = true;
 195             break;
 196         case DEMUX_GET_PTS_DELAY:
 197             *va_arg(args, vlc_tick_t *) =
 198                 VLC_TICK_FROM_MS( var_InheritInteger(demux, "disc-caching") );
 199             break;
 200
 201         case DEMUX_SET_PAUSE_STATE:
 202             break;
 203
 204         case DEMUX_GET_POSITION:
 205             *va_arg(args, double *) = (double)(sys->position)
 206                                       / (double)(sys->length);
 207             break;
 208
 209         case DEMUX_SET_POSITION:
 210             sys->position = lround(va_arg(args, double) * sys->length);
 211             break;
 212
 213         case DEMUX_GET_LENGTH:
 214             *va_arg(args, vlc_tick_t *) = (INT64_C(40000) * sys->length) / 3;
 215             break;
 216         case DEMUX_GET_TIME:
 217             *va_arg(args, vlc_tick_t *) = (INT64_C(40000) * sys->position) / 3;
 218             break;
 219         case DEMUX_SET_TIME:
 220             sys->position = (va_arg(args, vlc_tick_t) * 3) / INT64_C(40000);
 221             break;
 222
 223         default:
 224             return VLC_EGENERIC;
 225     }
 226     return VLC_SUCCESS;
 227 }
 228
 229 /*
 230  * Check for Mixed Audio/CDROM data
 231  *
 232  * ioctl will return first track # and last track # from last TOC
 233  * (this could start > 1..  but where's the case ?)
 234  *
 235  * vcdev_toc stores i_tracks as the number of STORED sectors info,
 236  * this is last - first track, plus one (the LEADOUT one)
 237  *
 238  * tracks can be DATA in mixed data/audio mode (CDROM spec, not CDDA)
 239  * and this is control flag (Subcode Channel Q)
 240  *
 241  * first: 1 last 13
 242  * track:   1 lba:         0 (        0) 00:02:00 adr: 1 control: 0 mode: -1
 243  * track:   2 lba:     16462 (    65848) 03:41:37 adr: 1 control: 0 mode: -1
 244  * ...
 245  * track:  12 lba:    212405 (   849620) 47:14:05 adr: 1 control: 0 mode: -1
 246  * track:  13 lba:    250948 (  1003792) 55:47:73 adr: 1 control: 4 mode: -1
 247  * track:lout lba:    266286 (  1065144) 59:12:36 adr: 1 control: 4 mode: -1
 248 */
 249 static int TOC_GetAudioRange(vcddev_toc_t *p_toc,
 250                              int *pi_first, int *pi_last)
 251 {
 252     if( p_toc->i_tracks < 1 )
 253         return 0;
 254
 255     int i_first = p_toc->i_first_track;
 256     int i_last = p_toc->i_last_track;
 257     for(int i=i_first; i<p_toc->i_tracks; i++)
 258     {
 259         if((p_toc->p_sectors[i - 1].i_control & CD_ROM_DATA_FLAG) == 0)
 260             break;
 261         i_first++;
 262     }
 263     for(int i=i_last; i > 0; i--)
 264     {
 265         if((p_toc->p_sectors[i - 1].i_control & CD_ROM_DATA_FLAG) == 0)
 266             break;
 267         i_last--;
 268     }
 269
 270     /* FIX copy protection TOC
 271      * https://github.com/metabrainz/libdiscid/blob/e46249415eb6d657ecc63667b03d670a4347712f/src/toc.c#L101 */
 272     do
 273     {
 274         vcddev_sector_t *p_last = &p_toc->p_sectors[i_last - p_toc->i_first_track];
 275         vcddev_sector_t *p_lout = &p_toc->p_sectors[p_toc->i_tracks];
 276         if(p_lout->i_lba > p_last->i_lba || i_last <= i_first)
 277             break;
 278         /* last audio is invalid, bigger than lead out */
 279         i_last = i_last - 1;
 280         p_toc->i_last_track = i_last;
 281         p_last->i_lba -= CD_ROM_XA_INTERVAL;
 282         p_toc->i_tracks--; /* change lead out */
 283     } while( i_last > i_first );
 284
 285     *pi_first = i_first;
 286     *pi_last = i_last;
 287     return (i_last >= i_first) ? i_last - i_first + 1 : 0;
 288 }
 289
 290 static int DemuxOpen(vlc_object_t *obj, vcddev_t *dev, unsigned track)
 291 {
 292     demux_t *demux = (demux_t *)obj;
 293
 294     if (demux->out == NULL)
 295         goto error;
 296
 297     demux_sys_t *sys = vlc_obj_malloc(obj, sizeof (*sys));
 298     if (unlikely(sys == NULL))
 299         goto error;
 300
 301     demux->p_sys = sys;
 302     sys->vcddev = dev;
 303     sys->start = var_InheritInteger(obj, "cdda-first-sector");
 304     sys->length = var_InheritInteger(obj, "cdda-last-sector") - sys->start;
 305
 306     /* Track number in input item */
 307     if (sys->start == (unsigned)-1 || sys->length == (unsigned)-1)
 308     {
 309         vcddev_toc_t *p_toc = ioctl_GetTOC(obj, dev, true);
 310         if(p_toc == NULL)
 311             goto error;
 312
 313         int i_cdda_tracks, i_cdda_first, i_cdda_last;
 314         i_cdda_tracks = TOC_GetAudioRange(p_toc, &i_cdda_first, &i_cdda_last);
 315
 316         if (track == 0 || track > (unsigned) i_cdda_tracks)
 317         {
 318             msg_Err(obj, "invalid track number: %u/%i", track, i_cdda_tracks);
 319             vcddev_toc_Free(p_toc);
 320             goto error;
 321         }
 322
 323         track--;
 324         int i_first_sector = p_toc->p_sectors[track].i_lba;
 325         int i_last_sector = p_toc->p_sectors[track + 1].i_lba;
 326         if(i_cdda_first + track == (unsigned) i_cdda_last && p_toc->i_last_track > i_cdda_last)
 327             i_last_sector -= CD_ROM_XA_INTERVAL;
 328
 329         sys->start = i_first_sector;
 330         sys->length = i_last_sector - i_first_sector;
 331         vcddev_toc_Free(p_toc);
 332     }
 333
 334     es_format_t fmt;
 335
 336     es_format_Init(&fmt, AUDIO_ES, VLC_CODEC_S16L);
 337     fmt.audio.i_rate = 44100;
 338     fmt.audio.i_channels = 2;
 339     sys->es = es_out_Add(demux->out, &fmt);
 340
 341     date_Init(&sys->pts, 44100, 1);
 342     date_Set(&sys->pts, VLC_TICK_0);
 343
 344     sys->position = 0;
 345     demux->pf_demux = Demux;
 346     demux->pf_control = DemuxControl;
 347     return VLC_SUCCESS;
 348
 349 error:
 350     ioctl_Close(obj, dev);
 351     return VLC_EGENERIC;
 352 }
 353
 354 /*****************************************************************************
 355  * Access: local prototypes
 356  *****************************************************************************/
 357 typedef struct
 358 {
 359     vcddev_t    *vcddev;                            /* vcd device descriptor */
 360     vcddev_toc_t *p_toc;                            /* Tracks TOC */
 361     int          i_cdda_tracks;                     /* # of audio tracks in TOC */
 362     int          i_cdda_first;                      /* First .. */
 363     int          i_cdda_last;                       /* Last .. */
 364     int          cdtextc;
 365     vlc_meta_t **cdtextv;
 366 #ifdef HAVE_LIBCDDB
 367     cddb_disc_t *cddb;
 368 #endif
 369     musicbrainz_recording_t *mbrecord;
 370 } access_sys_t;
 371
 372 static inline int LBAPregap( int i_sector )
 373 {
 374     /* LBA to sector pregap fixup
 375        see libdiscid/src/toc.c #L80 */
 376     return i_sector + 150;
 377 }
 378
 379 #ifdef HAVE_GCRYPT
 380 static char * BuildMusicbrainzDiscID( const vcddev_toc_t *p_toc,
 381                                       int i_total, int i_first, int i_last )
 382 {
 383     gcry_md_hd_t hd;
 384     gcry_error_t err = gcry_md_open( &hd, GCRY_MD_SHA1, 0 );
 385     if(err)
 386         return NULL;
 387
 388     if(gcry_md_enable( hd, GCRY_MD_SHA1 ))
 389     {
 390         gcry_md_close( hd );
 391         return NULL;
 392     }
 393
 394     char buffer[16];
 395
 396     sprintf( buffer, "%02X", i_first );
 397     gcry_md_write( hd, buffer, 2 );
 398     sprintf( buffer, "%02X", i_last );
 399     gcry_md_write( hd, buffer, 2 );
 400     /* LEAD OUT sector info */
 401
 402     /* LEAD OUT sector info
 403      * https://github.com/metabrainz/libdiscid/blob/e46249415eb6d657ecc63667b03d670a4347712f/src/toc.c#L90 */
 404     int i_last_track_end;
 405     if (p_toc->i_tracks > i_total)
 406         i_last_track_end = LBAPregap(p_toc->p_sectors[i_total].i_lba) - CD_ROM_XA_INTERVAL;
 407     else
 408         i_last_track_end = LBAPregap(p_toc->p_sectors[p_toc->i_tracks].i_lba);
 409
 410     sprintf( buffer, "%08X", i_last_track_end );
 411     gcry_md_write( hd, buffer, 8 );
 412
 413     for( int i = 0; i<i_total; i++ ) /* skip LEAD OUT */
 414     {
 415         sprintf( buffer, "%08X", LBAPregap(p_toc->p_sectors[i].i_lba) );
 416         gcry_md_write( hd, buffer, 8 );
 417     }
 418
 419     for( int i = i_total; i<100; i++ )
 420     {
 421         if( i == p_toc->i_tracks )
 422             continue;
 423         gcry_md_write( hd, "00000000", 8 );
 424     }
 425
 426     gcry_md_final( hd );
 427
 428     size_t i_len = gcry_md_get_algo_dlen( GCRY_MD_SHA1 );
 429     unsigned char *output = gcry_md_read( hd, GCRY_MD_SHA1 );
 430     char *out = vlc_b64_encode_binary( output, i_len );
 431     if( out )
 432     {
 433         i_len = strlen( out );
 434         for( size_t i=0; i<i_len; i++ )
 435         {
 436             if( !isalpha(out[i]) )
 437             {
 438                 if( out[i] == '+' )
 439                     out[i] = '.';
 440                 else if( out[i] == '/' )
 441                     out[i] = '_';
 442                 else if( out[i] == '=' )
 443                     out[i] = '-';
 444             }
 445         }
 446     }
 447
 448     gcry_md_close( hd );
 449
 450     return out;
 451 }
 452 #else
 453 # define BuildMusicbrainzDiscID(a, b, c, d) (NULL)
 454 #endif
 455
 456 static musicbrainz_recording_t * GetMusicbrainzInfo( vlc_object_t *obj,
 457                                                      const vcddev_toc_t *p_toc,
 458                                                      int i_total, int i_first, int i_last )
 459 {
 460     musicbrainz_recording_t *recording = NULL;
 461
 462     char *psz_mbserver = var_InheritString( obj, "musicbrainz-server" );
 463     if( !psz_mbserver || !*psz_mbserver )
 464         return NULL;
 465
 466     musicbrainz_config_t cfg = { .obj = obj,
 467                                  .psz_mb_server = psz_mbserver,
 468                                  .psz_coverart_server = NULL };
 469
 470     /* Build DISC ID based on SHA1 */
 471     char *psz_disc_id = BuildMusicbrainzDiscID( p_toc,
 472                                                 i_total, i_first, i_last );
 473     if( psz_disc_id )
 474     {
 475         recording = musicbrainz_lookup_recording_by_discid( &cfg, psz_disc_id );
 476     }
 477     else /* Fuzzy lookup using TOC */
 478     {
 479         struct vlc_memstream ms;
 480
 481         vlc_memstream_open(&ms);
 482         vlc_memstream_printf(&ms, "toc=%u+%u", i_first, i_last );
 483
 484         /* LEAD OUT sector info
 485          * https://github.com/metabrainz/libdiscid/blob/e46249415eb6d657ecc63667b03d670a4347712f/src/toc.c#L90 */
 486         int i_last_track_end;
 487         if (p_toc->i_tracks > i_total)
 488             i_last_track_end = LBAPregap(p_toc->p_sectors[i_total].i_lba) - CD_ROM_XA_INTERVAL;
 489         else
 490             i_last_track_end = LBAPregap(p_toc->p_sectors[p_toc->i_tracks].i_lba);
 491         vlc_memstream_printf(&ms, "+%u", i_last_track_end );
 492         for( int i = 0; i<i_total; i++ ) /* skipped LEAD OUT, audio only */
 493             vlc_memstream_printf(&ms, "+%u", LBAPregap(p_toc->p_sectors[i].i_lba) );
 494         if( vlc_memstream_close(&ms) == 0 )
 495         {
 496             recording = musicbrainz_lookup_recording_by_toc( &cfg, ms.ptr );
 497             free( ms.ptr );
 498         }
 499     }
 500
 501     free( psz_mbserver );
 502     return recording;
 503 }
 504
 505 #ifdef HAVE_LIBCDDB
 506 static cddb_disc_t *GetCDDBInfo( vlc_object_t *obj, const vcddev_toc_t *p_toc )
 507 {
 508     msg_Dbg( obj, "retrieving metadata with CDDB" );
 509
 510     /* */
 511     cddb_conn_t *p_cddb = cddb_new();
 512     if( !p_cddb )
 513     {
 514         msg_Warn( obj, "unable to use CDDB" );
 515         return NULL;
 516     }
 517
 518     /* */
 519
 520     cddb_http_enable( p_cddb );
 521
 522     char *psz_tmp = var_InheritString( obj, "cddb-server" );
 523     if( psz_tmp )
 524     {
 525         cddb_set_server_name( p_cddb, psz_tmp );
 526         free( psz_tmp );
 527     }
 528
 529     cddb_set_server_port( p_cddb, var_InheritInteger( obj, "cddb-port" ) );
 530
 531     cddb_set_email_address( p_cddb, "vlc@videolan.org" );
 532
 533     cddb_set_http_path_query( p_cddb, "/~cddb/cddb.cgi" );
 534     cddb_set_http_path_submit( p_cddb, "/~cddb/submit.cgi" );
 535
 536
 537     char *psz_cachedir;
 538     char *psz_temp = config_GetUserDir( VLC_CACHE_DIR );
 539
 540     if( asprintf( &psz_cachedir, "%s" DIR_SEP "cddb", psz_temp ) > 0 ) {
 541         cddb_cache_enable( p_cddb );
 542         cddb_cache_set_dir( p_cddb, psz_cachedir );
 543         free( psz_cachedir );
 544     }
 545     free( psz_temp );
 546
 547     cddb_set_timeout( p_cddb, 10 );
 548
 549     /* */
 550     cddb_disc_t *p_disc = cddb_disc_new();
 551     if( !p_disc )
 552     {
 553         msg_Err( obj, "unable to create CDDB disc structure." );
 554         goto error;
 555     }
 556
 557     int64_t i_length = 2000000; /* PreGap */
 558     for( int i = 0; i < p_toc->i_tracks; i++ )
 559     {
 560         cddb_track_t *t = cddb_track_new();
 561         cddb_track_set_frame_offset( t, p_toc->p_sectors[i].i_lba + 150 );  /* Pregap offset */
 562
 563         cddb_disc_add_track( p_disc, t );
 564         const int64_t i_size = ( p_toc->p_sectors[i+1].i_lba - p_toc->p_sectors[i].i_lba ) *
 565                                (int64_t)CDDA_DATA_SIZE;
 566         i_length += INT64_C(1000000) * i_size / 44100 / 4  ;
 567
 568         msg_Dbg( obj, "Track %i offset: %i", i, p_toc->p_sectors[i].i_lba + 150 );
 569     }
 570
 571     msg_Dbg( obj, "Total length: %i", (int)(i_length/1000000) );
 572     cddb_disc_set_length( p_disc, (int)(i_length/1000000) );
 573
 574     if( !cddb_disc_calc_discid( p_disc ) )
 575     {
 576         msg_Err( obj, "CDDB disc ID calculation failed" );
 577         goto error;
 578     }
 579
 580     const int i_matches = cddb_query( p_cddb, p_disc );
 581     if( i_matches < 0 )
 582     {
 583         msg_Warn( obj, "CDDB error: %s", cddb_error_str(errno) );
 584         goto error;
 585     }
 586     else if( i_matches == 0 )
 587     {
 588         msg_Dbg( obj, "Couldn't find any matches in CDDB." );
 589         goto error;
 590     }
 591     else if( i_matches > 1 )
 592         msg_Warn( obj, "found %d matches in CDDB. Using first one.", i_matches );
 593
 594     cddb_read( p_cddb, p_disc );
 595
 596     msg_Dbg( obj, "disc ID: 0x%08x", cddb_disc_get_discid(p_disc) );
 597
 598     cddb_destroy( p_cddb);
 599     return p_disc;
 600
 601 error:
 602     if( p_disc )
 603         cddb_disc_destroy( p_disc );
 604     cddb_destroy( p_cddb );
 605     msg_Dbg( obj, "CDDB failure" );
 606     return NULL;
 607 }
 608 #endif /* HAVE_LIBCDDB */
 609
 610 static void AccessGetMeta(stream_t *access, vlc_meta_t *meta)
 611 {
 612     access_sys_t *sys = access->p_sys;
 613
 614     vlc_meta_SetTitle(meta, "Audio CD");
 615
 616     /* Retrieve CD-TEXT information */
 617     if (sys->cdtextc > 0 && sys->cdtextv[0] != NULL)
 618         vlc_meta_Merge(meta, sys->cdtextv[0]);
 619
 620 /* Return true if the given string is not NULL and not empty */
 621 #define NONEMPTY( psz ) ( (psz) && *(psz) )
 622 /* If the given string is NULL or empty, fill it by the return value of 'code' */
 623 #define ON_EMPTY( psz, code ) do { if( !NONEMPTY( psz) ) { (psz) = code; } } while(0)
 624
 625     /* Retrieve CDDB information (preferred over CD-TEXT) */
 626 #ifdef HAVE_LIBCDDB
 627     if (sys->cddb != NULL)
 628     {
 629         const char *str = cddb_disc_get_title(sys->cddb);
 630         if (NONEMPTY(str))
 631             vlc_meta_SetTitle(meta, str);
 632
 633         str = cddb_disc_get_genre(sys->cddb);
 634         if (NONEMPTY(str))
 635             vlc_meta_SetGenre(meta, str);
 636
 637         const unsigned year = cddb_disc_get_year(sys->cddb);
 638         if (year != 0)
 639         {
 640             char yearbuf[5];
 641
 642             snprintf(yearbuf, sizeof (yearbuf), "%u", year);
 643             vlc_meta_SetDate(meta, yearbuf);
 644         }
 645
 646         /* Set artist only if identical across tracks */
 647         str = cddb_disc_get_artist(sys->cddb);
 648         if (NONEMPTY(str))
 649         {
 650             for (int i = 0; i < sys->p_toc->i_tracks; i++)
 651             {
 652                 cddb_track_t *t = cddb_disc_get_track(sys->cddb, i);
 653                 if (t == NULL)
 654                     continue;
 655
 656                 const char *track_artist = cddb_track_get_artist(t);
 657                 if (NONEMPTY(track_artist))
 658                 {
 659                     if (str == NULL)
 660                         str = track_artist;
 661                     else
 662                     if (strcmp(str, track_artist))
 663                     {
 664                         str = NULL;
 665                         break;
 666                     }
 667                 }
 668             }
 669         }
 670     }
 671 #endif
 672 }
 673
 674 static int ReadDir(stream_t *access, input_item_node_t *node)
 675 {
 676     access_sys_t *sys = access->p_sys;
 677     const vcddev_toc_t *p_toc = sys->p_toc;
 678
 679     /* Build title table */
 680     const int i_start_track_offset = sys->i_cdda_first - sys->p_toc->i_first_track;
 681     for (int i = 0; i < sys->i_cdda_tracks; i++)
 682     {
 683         if(i < i_start_track_offset)
 684             continue;
 685
 686         msg_Dbg(access, "track[%d] start=%d", i, p_toc->p_sectors[i].i_lba);
 687
 688         /* Initial/default name */
 689         char *name;
 690
 691         if (unlikely(asprintf(&name, _("Audio CD - Track %02i"),
 692                               i - i_start_track_offset + 1 ) == -1))
 693             name = NULL;
 694
 695         /* Create playlist items */
 696         int i_first_sector = p_toc->p_sectors[i].i_lba;
 697         int i_last_sector = p_toc->p_sectors[i + 1].i_lba;
 698         if(sys->i_cdda_first + i == sys->i_cdda_last &&
 699            p_toc->i_last_track > sys->i_cdda_last)
 700             i_last_sector -= CD_ROM_XA_INTERVAL;
 701
 702         const vlc_tick_t duration =
 703             (vlc_tick_t)(i_last_sector - i_first_sector)
 704             * CDDA_DATA_SIZE * CLOCK_FREQ / 44100 / 2 / 2;
 705
 706         input_item_t *item = input_item_NewDisc(access->psz_url,
 707                                                 (name != NULL) ? name :
 708                                                 access->psz_url, duration);
 709         free(name);
 710
 711         if (unlikely(item == NULL))
 712             continue;
 713
 714         char *opt;
 715         if (likely(asprintf(&opt, "cdda-track=%i", i + 1) != -1))
 716         {
 717             input_item_AddOption(item, opt, VLC_INPUT_OPTION_TRUSTED);
 718             free(opt);
 719         }
 720
 721         if (likely(asprintf(&opt, "cdda-first-sector=%i",
 722                             p_toc->p_sectors[i].i_lba) != -1))
 723         {
 724             input_item_AddOption(item, opt, VLC_INPUT_OPTION_TRUSTED);
 725             free(opt);
 726         }
 727
 728         if (likely(asprintf(&opt, "cdda-last-sector=%i", i_last_sector) != -1))
 729         {
 730             input_item_AddOption(item, opt, VLC_INPUT_OPTION_TRUSTED);
 731             free(opt);
 732         }
 733
 734         const char *title = NULL;
 735         const char *artist = NULL;
 736         const char *album = NULL;
 737         const char *genre = NULL;
 738         const char *description = NULL;
 739         int year = 0;
 740
 741 #ifdef HAVE_LIBCDDB
 742         if (sys->cddb != NULL)
 743         {
 744             cddb_track_t *t = cddb_disc_get_track(sys->cddb, i);
 745             if (t != NULL)
 746             {
 747                 title = cddb_track_get_title(t);
 748                 artist = cddb_track_get_artist(t);
 749             }
 750
 751             ON_EMPTY(artist, cddb_disc_get_artist(sys->cddb));
 752             album = cddb_disc_get_title(sys->cddb);
 753             genre = cddb_disc_get_genre(sys->cddb);
 754             year = cddb_disc_get_year(sys->cddb);
 755         }
 756 #endif
 757
 758         /* Per track CDText */
 759         if(sys->cdtextc > 0)
 760         {
 761             const vlc_meta_t *m;
 762             if (i + 1 < sys->cdtextc && (m = sys->cdtextv[i + 1]) != NULL)
 763             {
 764                 ON_EMPTY(title,       vlc_meta_Get(m, vlc_meta_Title));
 765                 ON_EMPTY(artist,      vlc_meta_Get(m, vlc_meta_Artist));
 766                 ON_EMPTY(genre,       vlc_meta_Get(m, vlc_meta_Genre));
 767                 ON_EMPTY(description, vlc_meta_Get(m, vlc_meta_Description));
 768             }
 769
 770             /* Album CDtext data */
 771             if ((m = sys->cdtextv[0]) != NULL)
 772             {
 773                 ON_EMPTY(artist,      vlc_meta_Get(m, vlc_meta_Artist));
 774                 ON_EMPTY(album,       vlc_meta_Get(m, vlc_meta_Album));
 775                 ON_EMPTY(genre,       vlc_meta_Get(m, vlc_meta_Genre));
 776                 ON_EMPTY(description, vlc_meta_Get(m, vlc_meta_Description));
 777             }
 778         }
 779
 780         if(sys->mbrecord && sys->mbrecord->i_release)
 781         {
 782             musicbrainz_release_t *r = sys->mbrecord->p_releases;
 783             for(size_t j=0; j<r->i_tracks; j++)
 784             {
 785                 if(r->p_tracks[j].i_index == (unsigned)i + 1)
 786                 {
 787                     if (r->p_tracks[j].psz_title)
 788                     {
 789                         ON_EMPTY(title, r->p_tracks[j].psz_title);
 790                         ON_EMPTY(artist, r->p_tracks[j].psz_artist);
 791                     }
 792                     break;
 793                 }
 794             }
 795             ON_EMPTY(album, r->psz_title);
 796             if(NONEMPTY(r->psz_artist))
 797             {
 798                 artist = r->psz_artist;
 799                 input_item_SetAlbumArtist(item, r->psz_artist);
 800             }
 801             if(year == 0 && r->psz_date)
 802             {
 803                 unsigned i_year;
 804                 if(sscanf(r->psz_date, "%4d", &i_year) == 1)
 805                     year = i_year;
 806             }
 807             if(NONEMPTY(r->psz_coverart_url))
 808                 input_item_SetArtworkURL(item, r->psz_coverart_url);
 809         }
 810
 811         if (NONEMPTY(title))
 812         {
 813             input_item_SetName(item, title);
 814             input_item_SetTitle(item, title);
 815         }
 816
 817         if (NONEMPTY(artist))
 818             input_item_SetArtist(item, artist);
 819
 820         if (NONEMPTY(genre))
 821             input_item_SetGenre(item, genre);
 822
 823         if (NONEMPTY(description))
 824             input_item_SetDescription(item, description);
 825
 826         if (NONEMPTY(album))
 827             input_item_SetAlbum(item, album);
 828
 829         if (year != 0)
 830         {
 831             char yearbuf[5];
 832
 833             snprintf(yearbuf, sizeof (yearbuf), "%u", year);
 834             input_item_SetDate(item, yearbuf);
 835         }
 836
 837         char num[4];
 838         if(snprintf(num, sizeof (num), "%u", i + 1) < 4)
 839             input_item_SetTrackNum(item, num);
 840         snprintf(num, sizeof (num), "%u", p_toc->i_tracks);
 841         input_item_SetTrackTotal(item, num);
 842
 843         input_item_node_AppendItem(node, item);
 844         input_item_Release(item);
 845     }
 846 #undef ON_EMPTY
 847 #undef NONEMPTY
 848     return VLC_SUCCESS;
 849 }
 850
 851 static int AccessControl(stream_t *access, int query, va_list args)
 852 {
 853     if (query == STREAM_GET_META)
 854     {
 855         AccessGetMeta(access, va_arg(args, vlc_meta_t *));
 856         return VLC_SUCCESS;
 857     }
 858     return access_vaDirectoryControlHelper(access, query, args);
 859 }
 860
 861 static int AccessOpen(vlc_object_t *obj, vcddev_t *dev)
 862 {
 863     stream_t *access = (stream_t *)obj;
 864     /* Only whole discs here */
 865     access_sys_t *sys = vlc_obj_malloc(obj, sizeof (*sys));
 866     if (unlikely(sys == NULL))
 867     {
 868         ioctl_Close(obj, dev);
 869         return VLC_ENOMEM;
 870     }
 871
 872     sys->vcddev = dev;
 873     sys->p_toc = ioctl_GetTOC(obj, dev, true);
 874     if (sys->p_toc == NULL)
 875     {
 876         msg_Err(obj, "cannot count tracks");
 877         goto error;
 878     }
 879
 880     sys->i_cdda_tracks = TOC_GetAudioRange(sys->p_toc, &sys->i_cdda_first, &sys->i_cdda_last);
 881     if (sys->i_cdda_tracks == 0)
 882     {
 883         msg_Err(obj, "no audio tracks found");
 884         vcddev_toc_Free(sys->p_toc);
 885         goto error;
 886     }
 887
 888     if (ioctl_GetCdText(obj, dev, &sys->cdtextv, &sys->cdtextc))
 889     {
 890         msg_Dbg(obj, "CD-TEXT information missing");
 891         sys->cdtextv = NULL;
 892         sys->cdtextc = 0;
 893     }
 894
 895     sys->mbrecord = NULL;
 896 #ifdef HAVE_LIBCDDB
 897     sys->cddb = NULL;
 898 #endif
 899
 900     if(var_InheritBool(obj, "metadata-network-access"))
 901     {
 902         sys->mbrecord = GetMusicbrainzInfo(obj, sys->p_toc, sys->i_cdda_tracks,
 903                                            sys->i_cdda_first, sys->i_cdda_last );
 904 #ifdef HAVE_LIBCDDB
 905         if(!sys->mbrecord)
 906             sys->cddb = GetCDDBInfo(obj, sys->p_toc);
 907 #endif
 908     }
 909     else msg_Dbg(obj, "album art policy set to manual: not fetching");
 910
 911     access->p_sys = sys;
 912     access->pf_read = NULL;
 913     access->pf_block = NULL;
 914     access->pf_readdir = ReadDir;
 915     access->pf_seek = NULL;
 916     access->pf_control = AccessControl;
 917     return VLC_SUCCESS;
 918
 919 error:
 920     ioctl_Close(obj, dev);
 921     return VLC_EGENERIC;
 922 }
 923
 924 static void AccessClose(access_sys_t *sys)
 925 {
 926     for (int i = 0; i < sys->cdtextc; i++)
 927     {
 928         vlc_meta_t *meta = sys->cdtextv[i];
 929         if (meta != NULL)
 930             vlc_meta_Delete(meta);
 931     }
 932     free(sys->cdtextv);
 933
 934 #ifdef HAVE_LIBCDDB
 935     if (sys->cddb != NULL)
 936         cddb_disc_destroy(sys->cddb);
 937 #endif
 938     if(sys->mbrecord)
 939         musicbrainz_recording_release(sys->mbrecord);
 940     vcddev_toc_Free(sys->p_toc);
 941 }
 942
 943 static int Open(vlc_object_t *obj)
 944 {
 945     stream_t *stream = (stream_t *)obj;
 946     unsigned track;
 947
 948     vcddev_t *dev = DiscOpen(obj, stream->psz_location, stream->psz_filepath,
 949                              &track);
 950     if (dev == NULL)
 951         return VLC_EGENERIC;
 952
 953     if (track == 0)
 954         return AccessOpen(obj, dev);
 955     else
 956         return DemuxOpen(obj, dev, track);
 957 }
 958
 959 static void Close(vlc_object_t *obj)
 960 {
 961     stream_t *stream = (stream_t *)obj;
 962     void *sys = stream->p_sys;
 963
 964     if (stream->pf_readdir != NULL)
 965         AccessClose(sys);
 966
 967     static_assert(offsetof(demux_sys_t, vcddev) == 0, "Invalid cast");
 968     static_assert(offsetof(access_sys_t, vcddev) == 0, "Invalid cast");
 969     ioctl_Close(obj, *(vcddev_t **)sys);
 970 }
 971
 972 /*****************************************************************************
 973  * Module descriptior
 974  *****************************************************************************/
 975 #define CDAUDIO_DEV_TEXT N_("Audio CD device")
 976 #if defined( _WIN32 ) || defined( __OS2__ )
 977 # define CDAUDIO_DEV_LONGTEXT N_( \
 978     "This is the default Audio CD drive (or file) to use. Don't forget the " \
 979     "colon after the drive letter (e.g. D:)")
 980 # define CD_DEVICE      "D:"
 981 #else
 982 # define CDAUDIO_DEV_LONGTEXT N_( \
 983     "This is the default Audio CD device to use." )
 984 # if defined(__OpenBSD__)
 985 #  define CD_DEVICE      "/dev/cd0c"
 986 # elif defined(__linux__)
 987 #  define CD_DEVICE      "/dev/sr0"
 988 # else
 989 #  define CD_DEVICE      "/dev/cdrom"
 990 # endif
 991 #endif
 992
 993 vlc_module_begin ()
 994     set_shortname( N_("Audio CD") )
 995     set_description( N_("Audio CD input") )
 996     set_capability( "access", 0 )
 997     set_category( CAT_INPUT )
 998     set_subcategory( SUBCAT_INPUT_ACCESS )
 999     set_callbacks(Open, Close)
1000
1001     add_loadfile("cd-audio", CD_DEVICE, CDAUDIO_DEV_TEXT, CDAUDIO_DEV_LONGTEXT)
1002
1003     add_usage_hint( N_("[cdda:][device][@[track]]") )
1004     add_integer( "cdda-track", 0 , NULL, NULL, true )
1005         change_volatile ()
1006     add_integer( "cdda-first-sector", -1, NULL, NULL, true )
1007         change_volatile ()
1008     add_integer( "cdda-last-sector", -1, NULL, NULL, true )
1009         change_volatile ()
1010
1011     add_string( "musicbrainz-server", MUSICBRAINZ_DEFAULT_SERVER,
1012                 N_( "Musicbrainz Server" ),
1013                 N_( "Address of the musicbrainz server to use." ), true )
1014 #ifdef HAVE_LIBCDDB
1015     add_string( "cddb-server", "freedb.videolan.org", N_( "CDDB Server" ),
1016             N_( "Address of the CDDB server to use." ), true )
1017     add_integer( "cddb-port", 80, N_( "CDDB port" ),
1018             N_( "CDDB Server port to use." ), true )
1019         change_integer_range( 1, 65535 )
1020 #endif
1021
1022     add_shortcut( "cdda", "cddasimple" )
1023 vlc_module_end ()