int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
unsigned long i_sleep_ms = (30 * 1000000);
if (argc > 1) {
p_cdio = cdio_open (argv[1], DRIVER_DEVICE);
if (argc > 2) {
errno = 0;
i_sleep_ms = strtol(argv[2], (char **)NULL, 10) * 1000000;
if ( (LONG_MIN == i_sleep_ms || LONG_MAX == i_sleep_ms) && errno != 0 ) {
printf("Invalid sleep parameter %s\n", argv[2]);
printf("Error reported back from strtol: %s\n", strerror(errno));
return 2;
}
}
} else {
p_cdio = cdio_open (NULL, DRIVER_DEVICE);
}
if (NULL == p_cdio) {
printf("Couldn't find a driver.. leaving.\n");
return 1;
}
if (cdio_get_media_changed(p_cdio))
printf("Initial media status: changed\n");
else
printf("Initial media status: not changed\n");
printf("Giving you %g seconds to change CD if you want to do so.\n",
i_sleep_ms / 1000000.0);
{
int i_ret = usleep(i_sleep_ms);
if (0 != i_ret)
fprintf(stderr, "Something went wrong with usleep\n");
}
if (cdio_get_media_changed(p_cdio))
printf("Media status: changed\n");
else
printf("Media status: not changed\n");
cdio_destroy(p_cdio);
return 0;
}
bool CddaSongLoader::HasChanged() {
if ((cdio_ && cdda_) && cdio_get_media_changed(cdio_) != 1) {
return false;
}
// Check if mutex is already token (i.e. init is already taking place)
if (!mutex_load_.tryLock()) {
return false;
}
mutex_load_.unlock();
return true;
}
static gint
xmms_cdda_read (xmms_xform_t *xform, void *buffer,
gint len, xmms_error_t *error)
{
xmms_cdda_data_t *data;
gint ret;
g_return_val_if_fail (xform, -1);
g_return_val_if_fail (buffer, -1);
g_return_val_if_fail (error, -1);
data = xmms_xform_private_data_get (xform);
g_return_val_if_fail (data, -1);
if (cdio_get_media_changed (data->cdio)) {
xmms_error_set (error, XMMS_ERROR_GENERIC, "CD ejected");
return -1;
}
if (data->current_lsn >= data->last_lsn) {
return 0;
}
if (data->buf_used == CDIO_CD_FRAMESIZE_RAW) {
cdio_cddap_read (data->drive, data->read_buf, data->current_lsn, 1);
data->current_lsn++;
data->buf_used = 0;
}
if (len >= CDIO_CD_FRAMESIZE_RAW) {
ret = CDIO_CD_FRAMESIZE_RAW - data->buf_used;
memcpy (buffer, data->read_buf + data->buf_used, ret);
} else {
gulong buf_left = CDIO_CD_FRAMESIZE_RAW - data->buf_used;
if (buf_left < len) {
memcpy (buffer, data->read_buf + data->buf_used, buf_left);
ret = buf_left;
} else {
memcpy (buffer, data->read_buf + data->buf_used, len);
ret = len;
}
}
data->buf_used += ret;
return ret;
}
/* mutex must be locked */
static void refresh_trackinfo (gboolean warning)
{
trigger_monitor ();
if (pcdrom_drive == NULL)
{
open_cd ();
if (pcdrom_drive == NULL)
return;
}
int mode = cdio_get_discmode (pcdrom_drive->p_cdio);
#ifdef _WIN32 /* cdio_get_discmode reports the wrong disk type sometimes */
if (mode == CDIO_DISC_MODE_NO_INFO || mode == CDIO_DISC_MODE_ERROR)
#else
if (mode != CDIO_DISC_MODE_CD_DA && mode != CDIO_DISC_MODE_CD_MIXED)
#endif
{
if (warning)
{
if (mode == CDIO_DISC_MODE_NO_INFO)
cdaudio_error (_("Drive is empty."));
else
cdaudio_error (_("Unsupported disk type."));
}
/* reset libcdio, else it will not read a new disk correctly */
if (pcdrom_drive)
{
cdda_close (pcdrom_drive);
pcdrom_drive = NULL;
}
g_free (trackinfo);
trackinfo = NULL;
return;
}
if (trackinfo == NULL || cdio_get_media_changed (pcdrom_drive->p_cdio))
{
g_free (trackinfo);
trackinfo = NULL;
scan_cd ();
}
}
void
cdda_scan_all_drives(void) {
char ** drives = NULL;
char touched[CDDA_DRIVES_MAX];
int i;
for (i = 0; i < CDDA_DRIVES_MAX; i++) {
if (cdda_drives[i].cdio != NULL) {
cdda_drives[i].media_changed = options.cdda_force_drive_rescan ?
1 : cdio_get_media_changed(cdda_drives[i].cdio);
if (cdda_drives[i].media_changed) {
cdio_destroy(cdda_drives[i].cdio);
cdda_drives[i].cdio = NULL;
}
}
}
drives = cdio_get_devices(DRIVER_DEVICE);
if (!drives)
return;
for (i = 0; i < CDDA_DRIVES_MAX; i++)
touched[i] = 0;
for (i = 0; (drives[i] != NULL) && (i < CDDA_DRIVES_MAX); i++) {
int n;
/* see if drives[i] is already known to us... */
cdda_drive_t * d = cdda_get_drive_by_device_path(drives[i]);
if (d != NULL) { /* yes */
n = cdda_get_n(drives[i]);
touched[n] = 1;
if (cdda_drives[n].media_changed) {
cdda_scan_drive(drives[i], cdda_get_drive(n));
if ((cdda_drives[n].disc.hash == 0L) ||
(cdda_drives[n].disc.hash != cdda_drives[n].disc.hash_prev)) {
/* EVENT refresh disc data */
cdda_send_event(CDDA_EVENT_CHANGED_DRIVE, drives[i]);
}
}
} else { /* no, scan the drive */
if (cdda_skip_extra_symlink(drives, i))
continue;
if (cdda_get_first_free_slot(&n) < 0) {
printf("cdda.c: error: too many CD drives\n");
return;
}
if (cdda_scan_drive(drives[i], cdda_get_drive(n)) >= 0) {
touched[n] = 1;
/* EVENT newly discovered drive */
cdda_send_event(CDDA_EVENT_NEW_DRIVE, drives[i]);
}
}
}
cdio_free_device_list(drives);
/* remove all drives that were not touched (those that disappeared) */
for (i = 0; i < CDDA_DRIVES_MAX; i++) {
if ((cdda_drives[i].device_path[0] != '\0') && (touched[i] == 0)) {
/* EVENT removed drive */
cdda_send_event(CDDA_EVENT_REMOVED_DRIVE, cdda_drives[i].device_path);
cdio_destroy(cdda_drives[i].cdio);
memset(cdda_drives + i, 0, sizeof(cdda_drive_t));
}
}
}
