Update to MPlayer SVN rev 29473 and FFmpeg SVN rev 19572.
[vaapi:athaifas-mplayer.git] / 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 const 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 int cdd_identify(const char *dev);
92 int cddb_resolve(const char *dev, char **xmcd_file);
93 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 CONFIG_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 CONFIG_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 CONFIG_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 CONFIG_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 CONFIG_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 CONFIG_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 CONFIG_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 #if HAVE_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 CONFIG_CDDB
442     "cddb",
443 #endif
444     NULL },
445   &stream_opts,
446   1 // Urls are an option string
447 };