stream/stream_cdda.c

   1 #include "config.h"
   2
   3 #include "stream.h"
   4 #include "m_option.h"
   5 #include "m_struct.h"
   6 #include "bswap.h"
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include "libmpdemux/demuxer.h"
  11
  12 #include "cdd.h"
  13
  14 #include "mp_msg.h"
  15 #include "help_mp.h"
  16
  17 #ifndef CD_FRAMESIZE_RAW
  18 #define CD_FRAMESIZE_RAW CDIO_CD_FRAMESIZE_RAW
  19 #endif
  20
  21
  22 extern char *cdrom_device;
  23
  24 static struct cdda_params {
  25   int speed;
  26   int paranoia_mode;
  27   char* generic_dev;
  28   int sector_size;
  29   int search_overlap;
  30   int toc_bias;
  31   int toc_offset;
  32   int no_skip;
  33   char* device;
  34   m_span_t span;
  35 } cdda_dflts = {
  36   -1,
  37   0,
  38   NULL,
  39   0,
  40   -1,
  41   0,
  42   0,
  43   0,
  44   NULL,
  45   { 0, 0 }
  46 };
  47
  48 #define ST_OFF(f) M_ST_OFF(struct cdda_params,f)
  49 m_option_t cdda_params_fields[] = {
  50   { "speed", ST_OFF(speed), CONF_TYPE_INT, M_OPT_RANGE,1,100, NULL },
  51   { "paranoia", ST_OFF(paranoia_mode), CONF_TYPE_INT,M_OPT_RANGE, 0, 2, NULL },
  52   { "generic-dev", ST_OFF(generic_dev), CONF_TYPE_STRING, 0, 0, 0, NULL },
  53   { "sector-size", ST_OFF(sector_size), CONF_TYPE_INT, M_OPT_RANGE,1,100, NULL },
  54   { "overlap", ST_OFF(search_overlap), CONF_TYPE_INT, M_OPT_RANGE,0,75, NULL },
  55   { "toc-bias", ST_OFF(toc_bias), CONF_TYPE_INT, 0, 0, 0, NULL },
  56   { "toc-offset", ST_OFF(toc_offset), CONF_TYPE_INT, 0, 0, 0, NULL },
  57   { "noskip", ST_OFF(no_skip), CONF_TYPE_FLAG, 0 , 0, 1, NULL },
  58   { "skip", ST_OFF(no_skip), CONF_TYPE_FLAG, 0 , 1, 0, NULL },
  59   { "device", ST_OFF(device), CONF_TYPE_STRING, 0, 0, 0, NULL },
  60   { "span",  ST_OFF(span), CONF_TYPE_OBJ_PARAMS, 0, 0, 0, &m_span_params_def },
  61   /// For url parsing
  62   { "hostname", ST_OFF(span), CONF_TYPE_OBJ_PARAMS, 0, 0, 0, &m_span_params_def },
  63   { "port", ST_OFF(speed), CONF_TYPE_INT, M_OPT_RANGE,1,100, NULL },
  64   { "filename", ST_OFF(device), CONF_TYPE_STRING, 0, 0, 0, NULL },
  65   {NULL, NULL, 0, 0, 0, 0, NULL}
  66 };
  67 static struct m_struct_st stream_opts = {
  68   "cdda",
  69   sizeof(struct cdda_params),
  70   &cdda_dflts,
  71   cdda_params_fields
  72 };
  73
  74 /// We keep these options but now they set the defaults
  75 m_option_t cdda_opts[] = {
  76   { "speed", &cdda_dflts.speed, CONF_TYPE_INT, M_OPT_RANGE,1,100, NULL },
  77   { "paranoia", &cdda_dflts.paranoia_mode, CONF_TYPE_INT,M_OPT_RANGE, 0, 2, NULL },
  78   { "generic-dev", &cdda_dflts.generic_dev, CONF_TYPE_STRING, 0, 0, 0, NULL },
  79   { "sector-size", &cdda_dflts.sector_size, CONF_TYPE_INT, M_OPT_RANGE,1,100, NULL },
  80   { "overlap", &cdda_dflts.search_overlap, CONF_TYPE_INT, M_OPT_RANGE,0,75, NULL },
  81   { "toc-bias", &cdda_dflts.toc_bias, CONF_TYPE_INT, 0, 0, 0, NULL },
  82   { "toc-offset", &cdda_dflts.toc_offset, CONF_TYPE_INT, 0, 0, 0, NULL },
  83   { "noskip", &cdda_dflts.no_skip, CONF_TYPE_FLAG, 0 , 0, 1, NULL },
  84   { "skip", &cdda_dflts.no_skip, CONF_TYPE_FLAG, 0 , 1, 0, NULL },
  85   { "device", &cdda_dflts.device, CONF_TYPE_STRING, 0, 0, 0, NULL },
  86   { "span", &cdda_dflts.span, CONF_TYPE_OBJ_PARAMS, 0, 0, 0, &m_span_params_def },
  87   {NULL, NULL, 0, 0, 0, 0, NULL}
  88 };
  89
  90 extern int cdd_identify(const char *dev);
  91 extern int cddb_resolve(const char *dev, char **xmcd_file);
  92 extern cd_info_t* cddb_parse_xmcd(char *xmcd_file);
  93
  94 static int seek(stream_t* s,off_t pos);
  95 static int fill_buffer(stream_t* s, char* buffer, int max_len);
  96 static void close_cdda(stream_t* s);
  97
  98 static int open_cdda(stream_t *st,int m, void* opts, int* file_format) {
  99   struct cdda_params* p = (struct cdda_params*)opts;
 100   int mode = p->paranoia_mode;
 101   int offset = p->toc_offset;
 102 #ifndef HAVE_LIBCDIO
 103   cdrom_drive* cdd = NULL;
 104 #else
 105   cdrom_drive_t* cdd = NULL;
 106 #endif
 107   cdda_priv* priv;
 108   cd_info_t *cd_info,*cddb_info = NULL;
 109   unsigned int audiolen=0;
 110   int last_track;
 111   int i;
 112   char *xmcd_file = NULL;
 113
 114   if(m != STREAM_READ) {
 115     m_struct_free(&stream_opts,opts);
 116     return STREAM_UNSUPORTED;
 117   }
 118
 119   if(!p->device) {
 120     if (cdrom_device)
 121       p->device = strdup(cdrom_device);
 122     else
 123       p->device = strdup(DEFAULT_CDROM_DEVICE);
 124   }
 125
 126 #ifdef MPLAYER_NETWORK
 127   // cdd_identify returns -1 if it cannot read the TOC,
 128   // in which case there is no point in calling cddb_resolve
 129   if(cdd_identify(p->device) >= 0 && strncmp(st->url,"cddb",4) == 0) {
 130     i = cddb_resolve(p->device, &xmcd_file);
 131     if(i == 0) {
 132       cddb_info = cddb_parse_xmcd(xmcd_file);
 133       free(xmcd_file);
 134     }
 135   }
 136 #endif
 137
 138 #ifndef HAVE_LIBCDIO
 139   if(p->generic_dev)
 140     cdd = cdda_identify_scsi(p->generic_dev,p->device,0,NULL);
 141   else
 142 #endif
 143 #if defined(__NetBSD__)
 144     cdd = cdda_identify_scsi(p->device,p->device,0,NULL);
 145 #else
 146     cdd = cdda_identify(p->device,0,NULL);
 147 #endif
 148
 149   if(!cdd) {
 150     mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_MPDEMUX_CDDA_CantOpenCDDADevice);
 151     m_struct_free(&stream_opts,opts);
 152     free(cddb_info);
 153     return STREAM_ERROR;
 154   }
 155
 156   cdda_verbose_set(cdd, CDDA_MESSAGE_FORGETIT, CDDA_MESSAGE_FORGETIT);
 157
 158   if(p->sector_size) {
 159     cdd->nsectors = p->sector_size;
 160 #ifndef HAVE_LIBCDIO
 161     cdd->bigbuff = p->sector_size * CD_FRAMESIZE_RAW;
 162 #endif
 163   }
 164
 165   if(cdda_open(cdd) != 0) {
 166     mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_MPDEMUX_CDDA_CantOpenDisc);
 167     cdda_close(cdd);
 168     m_struct_free(&stream_opts,opts);
 169     free(cddb_info);
 170     return STREAM_ERROR;
 171   }
 172
 173   cd_info = cd_info_new();
 174   mp_msg(MSGT_OPEN,MSGL_INFO,MSGTR_MPDEMUX_CDDA_AudioCDFoundWithNTracks,cdda_tracks(cdd));
 175   for(i=0;i<cdd->tracks;i++) {
 176           char track_name[80];
 177           long sec=cdda_track_firstsector(cdd,i+1);
 178           long off=cdda_track_lastsector(cdd,i+1)-sec+1;
 179
 180           sprintf(track_name, "Track %d", i+1);
 181           cd_info_add_track(cd_info, track_name, i+1, (unsigned int)(off/(60*75)), (unsigned int)((off/75)%60), (unsigned int)(off%75), sec, off );
 182           audiolen += off;
 183   }
 184   cd_info->min  = (unsigned int)(audiolen/(60*75));
 185   cd_info->sec  = (unsigned int)((audiolen/75)%60);
 186   cd_info->msec = (unsigned int)(audiolen%75);
 187
 188   priv = malloc(sizeof(cdda_priv));
 189   memset(priv, 0, sizeof(cdda_priv));
 190   priv->cd = cdd;
 191   priv->cd_info = cd_info;
 192
 193   if(p->toc_bias)
 194     offset -= cdda_track_firstsector(cdd,1);
 195
 196   if(offset) {
 197     int i;
 198     for(i = 0 ; i < cdd->tracks + 1 ; i++)
 199       cdd->disc_toc[i].dwStartSector += offset;
 200   }
 201
 202   if(p->speed)
 203     cdda_speed_set(cdd,p->speed);
 204
 205   last_track = cdda_tracks(cdd);
 206   if (p->span.start > last_track) p->span.start = last_track;
 207   if (p->span.end < p->span.start) p->span.end = p->span.start;
 208   if (p->span.end > last_track) p->span.end = last_track;
 209   if(p->span.start)
 210     priv->start_sector = cdda_track_firstsector(cdd,p->span.start);
 211   else
 212     priv->start_sector = cdda_disc_firstsector(cdd);
 213
 214   if(p->span.end) {
 215     priv->end_sector = cdda_track_lastsector(cdd,p->span.end);
 216   } else
 217     priv->end_sector = cdda_disc_lastsector(cdd);
 218
 219   priv->cdp = paranoia_init(cdd);
 220   if(priv->cdp == NULL) {
 221     cdda_close(cdd);
 222     free(priv);
 223     cd_info_free(cd_info);
 224     m_struct_free(&stream_opts,opts);
 225     free(cddb_info);
 226     return STREAM_ERROR;
 227   }
 228
 229   if(mode == 0)
 230     mode = PARANOIA_MODE_DISABLE;
 231   else if(mode == 1)
 232     mode = PARANOIA_MODE_OVERLAP;
 233   else
 234     mode = PARANOIA_MODE_FULL;
 235
 236   if(p->no_skip)
 237     mode |= PARANOIA_MODE_NEVERSKIP;
 238 #ifndef HAVE_LIBCDIO
 239   paranoia_modeset(cdd, mode);
 240
 241   if(p->search_overlap >= 0)
 242     paranoia_overlapset(cdd,p->search_overlap);
 243 #else
 244   paranoia_modeset(priv->cdp, mode);
 245
 246   if(p->search_overlap >= 0)
 247     paranoia_overlapset(priv->cdp,p->search_overlap);
 248 #endif
 249
 250   paranoia_seek(priv->cdp,priv->start_sector,SEEK_SET);
 251   priv->sector = priv->start_sector;
 252
 253 #ifdef MPLAYER_NETWORK
 254   if(cddb_info) {
 255     cd_info_free(cd_info);
 256     priv->cd_info = cddb_info;
 257     cd_info_debug( cddb_info );
 258   }
 259 #endif
 260
 261   st->priv = priv;
 262   st->start_pos = priv->start_sector*CD_FRAMESIZE_RAW;
 263   st->end_pos = priv->end_sector*CD_FRAMESIZE_RAW;
 264   st->type = STREAMTYPE_CDDA;
 265   st->sector_size = CD_FRAMESIZE_RAW;
 266
 267   st->fill_buffer = fill_buffer;
 268   st->seek = seek;
 269   st->close = close_cdda;
 270
 271   *file_format = DEMUXER_TYPE_RAWAUDIO;
 272
 273   m_struct_free(&stream_opts,opts);
 274
 275   return STREAM_OK;
 276 }
 277
 278 #ifndef HAVE_LIBCDIO
 279 static void cdparanoia_callback(long inpos, int function) {
 280 #else
 281 static void cdparanoia_callback(long int inpos, paranoia_cb_mode_t function) {
 282 #endif
 283 }
 284
 285 static int fill_buffer(stream_t* s, char* buffer, int max_len) {
 286   cdda_priv* p = (cdda_priv*)s->priv;
 287   cd_track_t *cd_track;
 288   int16_t * buf;
 289   int i;
 290
 291   buf = paranoia_read(p->cdp,cdparanoia_callback);
 292   if (!buf)
 293     return 0;
 294
 295 #ifdef WORDS_BIGENDIAN
 296   for(i=0;i<CD_FRAMESIZE_RAW/2;i++)
 297           buf[i]=le2me_16(buf[i]);
 298 #endif
 299
 300   p->sector++;
 301   s->pos = p->sector*CD_FRAMESIZE_RAW;
 302   memcpy(buffer,buf,CD_FRAMESIZE_RAW);
 303
 304   if((p->sector < p->start_sector) || (p->sector >= p->end_sector)) {
 305     s->eof = 1;
 306     return 0;
 307   }
 308
 309   for(i=0;i<p->cd->tracks;i++){
 310           if(p->cd->disc_toc[i].dwStartSector==p->sector-1) {
 311                   cd_track = cd_info_get_track(p->cd_info, i+1);
 312 //printf("Track %d, sector=%d\n", i, p->sector-1);
 313                   if( cd_track!=NULL ) {
 314                         mp_msg(MSGT_SEEK, MSGL_INFO, "\n%s\n", cd_track->name);
 315                         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CDDA_TRACK=%d\n", cd_track->track_nb);
 316                   }
 317                   break;
 318           }
 319   }
 320
 321
 322   return CD_FRAMESIZE_RAW;
 323 }
 324
 325 static int seek(stream_t* s,off_t newpos) {
 326   cdda_priv* p = (cdda_priv*)s->priv;
 327   cd_track_t *cd_track;
 328   int sec;
 329   int current_track=0, seeked_track=0;
 330   int i;
 331
 332   s->pos = newpos;
 333   if(s->pos < 0) {
 334     s->eof = 1;
 335     return 0;
 336   }
 337
 338   sec = s->pos/CD_FRAMESIZE_RAW;
 339 //printf("pos: %d, sec: %d ## %d\n", (int)s->pos, (int)sec, CD_FRAMESIZE_RAW);
 340 //printf("sector: %d  new: %d\n", p->sector, sec );
 341
 342   for(i=0;i<p->cd->tracks;i++){
 343 //        printf("trk #%d: %d .. %d\n",i,p->cd->disc_toc[i].dwStartSector,p->cd->disc_toc[i+1].dwStartSector);
 344         if( p->sector>=p->cd->disc_toc[i].dwStartSector && p->sector<p->cd->disc_toc[i+1].dwStartSector ) {
 345                 current_track = i;
 346         }
 347         if( sec>=p->cd->disc_toc[i].dwStartSector && sec<p->cd->disc_toc[i+1].dwStartSector ) {
 348                 seeked_track = i;
 349         }
 350   }
 351 //printf("current: %d, seeked: %d\n", current_track, seeked_track);
 352         if( current_track!=seeked_track ) {
 353 //printf("Track %d, sector=%d\n", seeked_track, sec);
 354                   cd_track = cd_info_get_track(p->cd_info, seeked_track+1);
 355                   if( cd_track!=NULL ) {
 356                           mp_msg(MSGT_SEEK, MSGL_INFO, "\n%s\n", cd_track->name);
 357                           mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CDDA_TRACK=%d\n", cd_track->track_nb);
 358                   }
 359
 360         }
 361 #if 0
 362   if(sec < p->start_sector)
 363     sec = p->start_sector;
 364   else if(sec > p->end_sector)
 365     sec = p->end_sector;
 366 #endif
 367
 368   p->sector = sec;
 369 //  s->pos = sec*CD_FRAMESIZE_RAW;
 370
 371 //printf("seek: %d, sec: %d\n", (int)s->pos, sec);
 372   paranoia_seek(p->cdp,sec,SEEK_SET);
 373   return 1;
 374 }
 375
 376 static void close_cdda(stream_t* s) {
 377   cdda_priv* p = (cdda_priv*)s->priv;
 378   paranoia_free(p->cdp);
 379   cdda_close(p->cd);
 380   cd_info_free(p->cd_info);
 381   free(p);
 382 }
 383
 384 stream_info_t stream_info_cdda = {
 385   "CDDA",
 386   "cdda",
 387   "Albeu",
 388   "",
 389   open_cdda,
 390   { "cdda", "cddb", NULL },
 391   &stream_opts,
 392   1 // Urls are an option string
 393 };