diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/input/cdda_input_plugin.c | 378 | ||||
| -rw-r--r-- | src/input/cdda_input_plugin.h | 28 |
2 files changed, 406 insertions, 0 deletions
diff --git a/src/input/cdda_input_plugin.c b/src/input/cdda_input_plugin.c new file mode 100644 index 000000000..6a9766ac2 --- /dev/null +++ b/src/input/cdda_input_plugin.c @@ -0,0 +1,378 @@ +/* + * Copyright (C) 2003-2010 The Music Player Daemon Project + * http://www.musicpd.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +/** + * CD-Audio handling (requires libcdio_paranoia) + */ + +#include "config.h" +#include "input_plugin.h" +#include "refcount.h" +#include "pcm_buffer.h" + +#include <stdio.h> +#include <stdint.h> +#include <stddef.h> +#include <string.h> +#include <stdlib.h> +#include <glib.h> +#include <assert.h> + +#include <cdio/paranoia.h> +#include <cdio/cd_types.h> + +struct input_cdda { + struct input_stream base; + + cdrom_drive_t *drv; + CdIo_t *cdio; + cdrom_paranoia_t *para; + + int endian; + + lsn_t lsn_from, lsn_to; + int lsn_relofs; + + int trackno; + + char buffer[CDIO_CD_FRAMESIZE_RAW]; + int buffer_lsn; + + struct pcm_buffer conv_buffer; +}; + +static const struct input_plugin cdda_inputplugin; + +static inline GQuark +cdda_quark(void) +{ + return g_quark_from_static_string("cdda"); +} + +static void +input_cdda_close(struct input_stream *is) +{ + struct input_cdda *i = (struct input_cdda *)is; + + pcm_buffer_deinit(&i->conv_buffer); + + if (i->para) + cdio_paranoia_free(i->para); + if (i->drv) + cdio_cddap_close_no_free_cdio( i->drv); + if (i->cdio) + cdio_destroy( i->cdio ); + + input_stream_deinit(&i->base); + g_free(i); +} + +static struct input_stream * +input_cdda_open(const char *uri, GError **error_r) +{ + struct input_cdda *i; + int idx; + char **cd_drives; /* List of all drives with a loaded CDDA in it. */ + + if (!g_str_has_prefix(uri, "cdda://")) + return NULL; + + i = g_new(struct input_cdda, 1); + input_stream_init(&i->base, &input_plugin_cdda, uri); + + /* initialize everything (should be already) */ + i->drv = NULL; + i->cdio = NULL; + i->para = NULL; + pcm_buffer_init(&i->conv_buffer); + + if (parse_cdda_uri(uri, &drive, &trackno) == -1) { + g_set_error(error_r, cdda_quark(), 0, + "Unable parse URI\n"); + input_cdda_close(i); + return NULL; + } + + /* get list of CD's supporting CD-DA */ + cd_drives = cdio_get_devices_with_cap(NULL, CDIO_FS_AUDIO, false); + if (!cd_drives) { + g_set_error(error_r, cdda_quark(), 0, + "Unable find or access a CD-ROM drive with an audio CD in it.\n"); + input_cdda_close(i); + return NULL; + } + + /* list all available drives */ + idx = 0; + while (cd_drives[idx] != NULL) { + g_debug("CD drive: %s\n", cd_drives[idx++]); + } + + /* Found such a CD-ROM with a CD-DA loaded. Use the first drive in the list. */ + i->cdio = cdio_open(*cd_drives, DRIVER_UNKNOWN); + i->drv = cdio_cddap_identify_cdio(i->cdio, 1, NULL); + + /* Don't need a list of CD's with CD-DA's any more. */ + cdio_free_device_list(cd_drives); + + if ( !i->drv ) { + g_set_error(error_r, cdda_quark(), 0, "Unable to identify audio CD disc.\n"); + input_cdda_close(i); + return NULL; + } + + /* We'll set for verbose paranoia messages. */ + cdda_verbose_set(i->drv, CDDA_MESSAGE_PRINTIT, CDDA_MESSAGE_PRINTIT); + + if ( 0 != cdio_cddap_open(i->drv) ) { + g_set_error(error_r, cdda_quark(), 0, "Unable to open disc.\n"); + input_cdda_close(i); + return NULL; + } + + i->endian = data_bigendianp(i->drv); + switch (i->endian) { + case -1: + g_debug("cdda: drive returns unknown audio data, assuming Little Endian\n"); + i->endian = 0; + break; + case 0: + g_debug("cdda: drive returns audio data Little Endian."); + break; + case 1: + g_debug("cdda: drive returns audio data Big Endian.\n"); + break; + default: + g_set_error(error_r, cdda_quark(), 0, "Drive returns unknown data type %d.\n", i->endian); + input_cdda_close(i) + return NULL; + } + + g_debug("Disc last LSN: %d\n", cdio_get_disc_last_lsn(i->cdio)); + + tracks = cdio_get_num_tracks(i->cdio); + first_track = cdio_get_first_track_num(i->cdio); + + { + int ti, j, tracks, first_track; + + g_debug("CD-ROM Track List (%i - %i)\n", first_track, first_track+tracks-1); + g_debug(" #: LSN\n"); + + /* generate track listing */ + for (j = 0, ti = first_track; j < tracks; ti++, j++) { + lsn_t lsn = cdio_get_track_lsn(i->cdio, ti); + if (CDIO_INVALID_LSN != lsn) { + g_debug("%3d: %06lu\n", (int) ti, (long unsigned int) lsn); + } + } + g_debug("%3X: %06lu leadout\n", CDIO_CDROM_LEADOUT_TRACK, + (long unsigned int) cdio_get_track_lsn(i->cdio, + CDIO_CDROM_LEADOUT_TRACK)); + } + + if (i->trackno == -1) { + g_set_error(error_r, cdda_quark(), 0, + "Invalid track # in %s", uri); + input_cdda_close(i); + return NULL; + } + + + i->lsn_relofs = 0; + i->lsn_from = cdio_get_track_lsn( i->cdio, i->trackno ); + i->lsn_to = cdio_get_track_last_lsn( i->cdio, i->trackno ); + + i->para = cdio_paranoia_init(i->drv); + + /* Set reading mode for full paranoia, but allow skipping sectors. */ + paranoia_modeset(i->para, PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP); + + /* seek to beginning of the track */ + cdio_paranoia_seek(i->para, i->lsn_from, SEEK_SET); + + i->eof = false; + + i->base.ready = true; + i->base.seekable = true; + i->base.size = (i->lsn_to - i->lsn_from + 1) * CDIO_CD_FRAMESIZE_RAW; + + /* hack to make MPD select the "pcm" decoder plugin */ + i->base.mime = g_strdup("audio/x-mpd-cdda-pcm"); + + return &i->base; +} + + +/* single archive handling */ +static int +input_cdda_archive_extract_trackno(const char *path) +{ + long value; + char *endptr, *str; + + //remove .wav + str = strrchr(path, '.'); + if (str) + *str = 0; + + //remove leading 0's + while (*path == '0') + path++; + + value = strtol(path, &endptr, 0); + if (*endptr != 0 || value < 0) { + return -1; + } + return value; +} + +static bool +input_cdda_seek(struct input_stream *is, + goffset offset, int whence, GError **error_r) +{ + struct input_cdda *cis = (struct input_cdda *)is; + + /* calculate absolute offset */ + switch (whence) { + case SEEK_SET: + break; + case SEEK_CUR: + offset += cis->base.offset; + break; + case SEEK_END: + offset += cis->base.size; + break; + } + + if (offset < 0 || offset > cis->base.size) { + g_set_error(error_r, cdda_quark(), 0, + "Invalid offset to seek %ld (%ld)", + (long int)offset, (long int)cis->base.size); + return false; + } + + /* simple case */ + if (offset == cis->base.offset) + return true; + + /* calculate current LSN */ + cis->lsn_relofs = offset / CDIO_CD_FRAMESIZE_RAW; + cis->base.offset = offset; + + cdio_paranoia_seek(cis->para, cis->lsn_from + cis->lsn_relofs, SEEK_SET); + + return true; +} + +static size_t +input_cdda_read(struct input_stream *is, void *ptr, size_t length, + GError **error_r) +{ + struct input_cdda *cis = (struct input_cdda *)is; + size_t nbytes = 0; + int diff; + size_t len, maxwrite; + int16_t *rbuf; + char *s_err, *s_mess; + char *wptr = (char *) ptr; + + while (length > 0) { + + + /* end of track ? */ + if (cis->lsn_from + cis->lsn_relofs > cis->lsn_to) + break; + + //current sector was changed ? + if (cis->lsn_relofs != cis->buffer_lsn) { + rbuf = cdio_paranoia_read(cis->para, NULL); + + s_err = cdda_errors(cis->archive->drv); + if (s_err) { + g_warning("paranoia_read: %s\n", s_err ); + free(s_err); + } + s_mess = cdda_messages(cis->archive->drv); + if (s_mess) { + g_debug("paranoia_read: %s\n", s_mess ); + free(s_mess); + } + if (!rbuf) { + g_set_error(error_r, cdda_quark(), 0, + "paranoia read error. Stopping.\n"); + return 0; + } + //do the swapping if nessesary + if (cis->archive->endian != 0) { + g_debug("swap\n"); + uint16_t *conv_buffer = pcm_buffer_get(&cis->conv_buffer, CDIO_CD_FRAMESIZE_RAW ); + /* do endian conversion ! */ + pcm16_to_wave( conv_buffer, (uint16_t*) rbuf, CDIO_CD_FRAMESIZE_RAW); + rbuf = (int16_t *)conv_buffer; + } + //store current buffer + memcpy(cis->buffer, rbuf, CDIO_CD_FRAMESIZE_RAW); + cis->buffer_lsn = cis->lsn_relofs; + } else { + //use cached sector + rbuf = (int16_t*) cis->buffer; + } + + //correct offset + diff = cis->base.offset - cis->lsn_relofs * CDIO_CD_FRAMESIZE_RAW; + + assert(diff >= 0 && diff < CDIO_CD_FRAMESIZE_RAW); + + maxwrite = CDIO_CD_FRAMESIZE_RAW - diff; //# of bytes pending in current buffer + len = (length < maxwrite? length : maxwrite); + + //skip diff bytes from this lsn + memcpy(wptr, ((char*)rbuf) + diff, len); + //update pointer + wptr += len; + nbytes += len; + + //update offset + cis->base.offset += len; + cis->lsn_relofs = cis->base.offset / CDIO_CD_FRAMESIZE_RAW; + //update length + length -= len; + } + + return nbytes; +} + +static bool +input_cdda_eof(struct input_stream *is) +{ + struct input_cdda *cis = (struct input_cdda *)is; + + return (cis->lsn_from + cis->lsn_relofs > cis->lsn_to); +} + + +static const struct input_plugin input_plugin_cdda = { + .open = input_cdda_open, + .close = input_cdda_close, + .seek = input_cdda_seek, + .read = input_cdda_read, + .eof = input_cdda_eof +}; + diff --git a/src/input/cdda_input_plugin.h b/src/input/cdda_input_plugin.h new file mode 100644 index 000000000..9104fd4d6 --- /dev/null +++ b/src/input/cdda_input_plugin.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2003-2010 The Music Player Daemon Project + * http://www.musicpd.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef MPD_CDDA_INPUT_PLUGIN_H +#define MPD_CDDA_INPUT_PLUGIN_H + +/** + * An input plugin based on libcdio_paranoia library. + */ +extern const struct input_plugin input_plugin_cdda; + +#endif |