stream/stream_cdda.c

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