int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio = cdio_open (NULL, DRIVER_UNKNOWN);
track_t i_first_track;
track_t i_tracks;
int j, i;
if (NULL == p_cdio) {
printf("Couldn't find a driver.. leaving.\n");
return 1;
}
printf("Disc last LSN: %d\n", cdio_get_disc_last_lsn(p_cdio));
i_tracks = cdio_get_num_tracks(p_cdio);
i_first_track = i = cdio_get_first_track_num(p_cdio);
printf("CD-ROM Track List (%i - %i)\n", i_first_track,
i_first_track+i_tracks-1);
printf(" #: LSN\n");
for (j = 0; j < i_tracks; i++, j++) {
lsn_t lsn = cdio_get_track_lsn(p_cdio, i);
if (CDIO_INVALID_LSN != lsn)
printf("%3d: %06lu\n", (int) i, (long unsigned int) lsn);
}
printf("%3X: %06lu leadout\n", CDIO_CDROM_LEADOUT_TRACK,
(long unsigned int) cdio_get_track_lsn(p_cdio,
CDIO_CDROM_LEADOUT_TRACK));
cdio_destroy(p_cdio);
return 0;
}
/**
* Given a CDIO device, calculates the necessary information about the device
* and contacts a CDDB server to get disk information.
*
* @param p_cdio a CDIO device
* @param disk the disk structure to store the information in
*
* @return an error status about whether information was obtained
*/
enum giles_cddb_err get_cddb_info_for_device(const CdIo_t *p_cdio, cddb_disc_t *disc) {
lsn_t last_lsn;
msf_t last_msf;
unsigned disc_len_in_s, i, matches;
track_t num_tracks;
cddb_track_t *track;
cddb_conn_t *conn;
num_tracks = cdio_get_num_tracks(p_cdio);
DPRINTF ("Disc contains %d tracks\n", num_tracks);
for (i = 1; i <= num_tracks; i++) {
track = cddb_track_new();
cddb_track_set_frame_offset(track, cdio_get_track_lba(p_cdio, i));
DPRINTF ("Offset for track %d is %d\n", i, cdio_get_track_lba(p_cdio, i));
cddb_disc_add_track(disc, track);
}
last_lsn = cdio_get_disc_last_lsn(p_cdio);
cdio_lsn_to_msf(last_lsn, &last_msf);
disc_len_in_s = cdio_audio_get_msf_seconds(&last_msf);
cddb_disc_set_length(disc, disc_len_in_s);
conn = cddb_new();
if (conn == NULL) {
cddb_error_print(cddb_errno(conn));
return giles_cddb_err_no_conn;
}
matches = cddb_query(conn, disc);
if (matches == -1) {
return giles_cddb_err_no_conn;
} else if (matches == 0) {
return giles_cddb_err_no_match;
}
cddb_read(conn, disc);
cddb_destroy(conn);
return giles_cddb_err_none;
}
static void cued_rip_prologue(rip_context_t *rip)
{
rip->mmcBuf = NULL;
rip->allocatedSectors = 0;
#ifdef CUED_HAVE_PARANOIA
if (ripUseParanoia) {
char *msg = 0;
int rc;
// N.B. this behavior does not match documentation:
// the 0 here appears to prevent the message "Checking <filename> for cdrom..."
rip->paranoiaCtlObj = cdio_cddap_identify_cdio(rip->cdObj, 0, &msg);
if (rip->paranoiaCtlObj) {
if (msg) {
cdio_warn("identify returned paranoia message(s) \"%s\"", msg);
}
cdio_cddap_verbose_set(rip->paranoiaCtlObj, CDDA_MESSAGE_LOGIT, CDDA_MESSAGE_LOGIT);
rc = cdio_cddap_open(rip->paranoiaCtlObj);
cdio2_paranoia_msg(rip->paranoiaCtlObj, "open of device");
if (!rc) {
rip->paranoiaRipObj = cdio_paranoia_init(rip->paranoiaCtlObj);
cdio2_paranoia_msg(rip->paranoiaCtlObj, "initialization of paranoia");
if (!rip->paranoiaRipObj) {
cdio2_abort("out of memory initializing paranoia");
}
cdio_paranoia_modeset(rip->paranoiaRipObj, PARANOIA_MODE_FULL ^ PARANOIA_MODE_NEVERSKIP);
// N.B. not needed at the moment
cdio2_paranoia_msg(rip->paranoiaCtlObj, "setting of paranoia mode");
rip->save_read_paranoid = rip->paranoiaCtlObj->read_audio;
rip->paranoiaCtlObj->read_audio = cued_read_paranoid;
} else {
cdio_cddap_close_no_free_cdio(rip->paranoiaCtlObj);
cdio_error("disabling paranoia");
CLRF(RIP_F_USE_PARANOIA, rip->flags);
}
} else {
cdio_error("disabling paranoia due to the following message(s):\n%s", msg);
CLRF(RIP_F_USE_PARANOIA, rip->flags);
}
}
#endif // CUED_HAVE_PARANOIA
if (rip->qSubChannelFileName) {
if (!strcmp("-", rip->qSubChannelFileName)) {
rip->qSubChannelFile = stdout;
} else {
(void) format_get_file_path(rip->cdObj, rip->cddbObj, rip->qSubChannelFileName, "", 0, rip->fileNameBuffer, rip->bufferSize);
// replaced O_EXCL with O_TRUNC to allow using /dev/null for testing
rip->qSubChannelFile = fopen2(rip->fileNameBuffer, O_WRONLY | O_CREAT | O_TRUNC | O_APPEND, 0666);
if (!rip->qSubChannelFile) {
cdio2_unix_error("fopen2", rip->fileNameBuffer, 0);
cdio_error("not creating sub-channel file \"%s\"", rip->fileNameBuffer);
rip->qSubChannelFileName = 0;
}
}
}
rip->endOfDiscSector = cdio_get_disc_last_lsn(rip->cdObj);
if (CDIO_INVALID_LSN == rip->endOfDiscSector) {
cdio2_abort("failed to get last sector number");
} else {
//cdio_debug("end of disc sector is %d", rip->endOfDiscSector);
}
}
static struct input_stream *
input_cdio_open(const char *uri,
GMutex *mutex, GCond *cond,
GError **error_r)
{
struct input_cdio_paranoia *i;
struct cdio_uri parsed_uri;
if (!parse_cdio_uri(&parsed_uri, uri, error_r))
return NULL;
i = g_new(struct input_cdio_paranoia, 1);
input_stream_init(&i->base, &input_plugin_cdio_paranoia, uri,
mutex, cond);
/* initialize everything (should be already) */
i->drv = NULL;
i->cdio = NULL;
i->para = NULL;
i->trackno = parsed_uri.track;
pcm_buffer_init(&i->conv_buffer);
/* get list of CD's supporting CD-DA */
char *device = parsed_uri.device[0] != 0
? g_strdup(parsed_uri.device)
: cdio_detect_device();
if (device == NULL) {
g_set_error(error_r, cdio_quark(), 0,
"Unable find or access a CD-ROM drive with an audio CD in it.");
input_cdio_close(&i->base);
return NULL;
}
/* Found such a CD-ROM with a CD-DA loaded. Use the first drive in the list. */
i->cdio = cdio_open(device, DRIVER_UNKNOWN);
g_free(device);
i->drv = cdio_cddap_identify_cdio(i->cdio, 1, NULL);
if ( !i->drv ) {
g_set_error(error_r, cdio_quark(), 0,
"Unable to identify audio CD disc.");
input_cdio_close(&i->base);
return NULL;
}
cdda_verbose_set(i->drv, CDDA_MESSAGE_FORGETIT, CDDA_MESSAGE_FORGETIT);
if ( 0 != cdio_cddap_open(i->drv) ) {
g_set_error(error_r, cdio_quark(), 0, "Unable to open disc.");
input_cdio_close(&i->base);
return NULL;
}
i->endian = data_bigendianp(i->drv);
switch (i->endian) {
case -1:
g_debug("cdda: drive returns unknown audio data, assuming Little Endian");
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.");
break;
default:
g_set_error(error_r, cdio_quark(), 0,
"Drive returns unknown data type %d", i->endian);
input_cdio_close(&i->base);
return NULL;
}
i->lsn_relofs = 0;
if (i->trackno >= 0) {
i->lsn_from = cdio_get_track_lsn(i->cdio, i->trackno);
i->lsn_to = cdio_get_track_last_lsn(i->cdio, i->trackno);
} else {
i->lsn_from = 0;
i->lsn_to = cdio_get_disc_last_lsn(i->cdio);
}
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->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;
}
