int bgav_check_device_vcd(const char * device, char ** name)
{
CdIo_t * cdio;
cdio_drive_read_cap_t read_cap;
cdio_drive_write_cap_t write_cap;
cdio_drive_misc_cap_t misc_cap;
cdio = cdio_open (device, DRIVER_DEVICE);
if(!cdio)
return 0;
cdio_get_drive_cap(cdio, &read_cap, &write_cap, &misc_cap);
if(!(read_cap & CDIO_DRIVE_CAP_READ_MODE2_FORM2))
{
cdio_destroy(cdio);
return 0;
}
/* Seems the drive is ok */
if(name)
*name = get_device_name(cdio, read_cap, write_cap, device);
cdio_destroy(cdio);
return 1;
}
int
main(int argc, const char *argv[])
{
track_t i_first_track;
track_t i_tracks;
CdIo_t *p_cdio = cdio_open ("../test/cdda.cue", DRIVER_BINCUE);
if (NULL == p_cdio) {
printf("Couldn't open ../test/cdda.cue with BIN/CUE driver.\n");
} else {
i_first_track = cdio_get_first_track_num(p_cdio);
i_tracks = cdio_get_num_tracks(p_cdio);
print_disc_info(p_cdio, i_tracks, i_first_track);
cdio_destroy(p_cdio);
}
p_cdio = cdio_open (NULL, DRIVER_DEVICE);
i_first_track = cdio_get_first_track_num(p_cdio);
i_tracks = cdio_get_num_tracks(p_cdio);
if (NULL == p_cdio) {
printf("Couldn't find CD\n");
return 1;
} else {
print_disc_info(p_cdio, i_tracks, i_first_track);
}
cdio_destroy(p_cdio);
return 0;
}
QString CddaLister::MakeFriendlyName(const QString& id) {
CdIo_t *cdio = cdio_open (id.toLocal8Bit().constData(), DRIVER_DEVICE);
cdio_hwinfo_t cd_info;
if (cdio_get_hwinfo(cdio, &cd_info)) {
cdio_destroy(cdio);
return QString(cd_info.psz_model);
}
cdio_destroy(cdio);
return QString("CD (") + id + ")";
}
QString CddaLister::DeviceModel(const QString& id) {
CdIo_t *cdio = cdio_open (id.toLocal8Bit().constData(), DRIVER_DEVICE);
cdio_hwinfo_t cd_info;
if (cdio_get_hwinfo(cdio, &cd_info)) {
cdio_destroy(cdio);
return QString(cd_info.psz_model);
}
cdio_destroy(cdio);
return QString();
}
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
char **ppsz_drives=NULL;
cdio_loglevel_default = (argc > 1) ? CDIO_LOG_DEBUG : CDIO_LOG_INFO;
/* snprintf(psz_nrgfile, sizeof(psz_nrgfile)-1,
"%s/%s", TEST_DIR, cue_file[i]);
*/
if (!cdio_have_driver(DRIVER_SOLARIS)) return(77);
ppsz_drives = cdio_get_devices(DRIVER_DEVICE);
if (!ppsz_drives) {
printf("Can't find a CD-ROM drive. Skipping test.\n");
exit(77);
}
p_cdio = cdio_open_linux(ppsz_drives[0]);
if (p_cdio) {
const char *psz_source = cdio_get_arg(p_cdio, "source");
if (0 != strncmp(psz_source, ppsz_drives[0],
strlen(ppsz_drives[0]))) {
fprintf(stderr,
"Got %s; should get back %s, the name we opened.\n",
psz_source, ppsz_drives[0]);
exit(1);
}
}
cdio_destroy(p_cdio);
p_cdio = cdio_open_am_linux(ppsz_drives[0], "SCSI");
if (p_cdio) {
const char *psz_access_mode = cdio_get_arg(p_cdio, "access-mode");
if (0 != strncmp(psz_access_mode, "SCSI", strlen("SCSI"))) {
fprintf(stderr,
"Got %s; Should get back %s, the access mode requested.\n",
psz_access_mode, "SCSI");
exit(2);
}
}
cdio_destroy(p_cdio);
cdio_free_device_list(ppsz_drives);
return 0;
}
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio = cdio_open (NULL, DRIVER_UNKNOWN);
driver_id_t driver_id;
if (NULL != p_cdio) {
char *default_device = cdio_get_default_device(p_cdio);
cdio_drive_read_cap_t i_read_cap;
cdio_drive_write_cap_t i_write_cap;
cdio_drive_misc_cap_t i_misc_cap;
printf("The driver selected is %s\n", cdio_get_driver_name(p_cdio));
if (default_device)
printf("The default device for this driver is %s\n", default_device);
cdio_get_drive_cap(p_cdio, &i_read_cap, &i_write_cap, &i_misc_cap);
print_drive_capabilities(i_read_cap, i_write_cap, i_misc_cap);
free(default_device);
cdio_destroy(p_cdio);
printf("\n");
} else {
printf("Problem in trying to find a driver.\n\n");
}
for (driver_id=CDIO_MIN_DRIVER; driver_id<=CDIO_MAX_DRIVER; ++driver_id)
if (cdio_have_driver(driver_id))
printf("We have: %s\n", cdio_driver_describe(driver_id));
else
printf("We don't have: %s\n", cdio_driver_describe(driver_id));
return 0;
}
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
const char *psz_drive = NULL;
if (argc > 1) psz_drive = argv[1];
p_cdio = cdio_open (psz_drive, DRIVER_UNKNOWN);
if (!p_cdio) {
printf("Couldn't find CD\n");
return 1;
} else {
uint8_t buf[22] = { 0, }; /* Place to hold returned data */
char *psz_cd = cdio_get_default_device(p_cdio);
if (DRIVER_OP_SUCCESS == mmc_mode_sense_6(p_cdio, buf, sizeof(buf),
CDIO_MMC_CAPABILITIES_PAGE) ) {
print_mode_sense(psz_cd, "6", buf);
} else {
printf("Couldn't get MODE_SENSE 6 data.\n");
}
if (DRIVER_OP_SUCCESS == mmc_mode_sense_10(p_cdio, buf, sizeof(buf),
CDIO_MMC_CAPABILITIES_PAGE) ) {
print_mode_sense(psz_cd, "10", buf);
} else {
printf("Couldn't get MODE_SENSE 10 data.\n");
}
free(psz_cd);
}
cdio_destroy(p_cdio);
return 0;
}
static void
CDDAReader_dealloc_image(cdio_CDDAReader *self)
{
if (self->_.image.image != NULL) {
cdio_destroy(self->_.image.image);
}
}
void *
cdda_scanner(void * arg) {
int i = 0;
cdio_log_set_handler(cdda_log_handler);
AQUALUNG_MUTEX_LOCK(cdda_mutex)
cdda_scan_all_drives();
AQUALUNG_MUTEX_UNLOCK(cdda_mutex)
while (cdda_scanner_working) {
g_usleep(100000);
if (i == 50) { /* scan every 5 seconds */
AQUALUNG_MUTEX_LOCK(cdda_mutex)
cdda_scan_all_drives();
AQUALUNG_MUTEX_UNLOCK(cdda_mutex)
i = 0;
}
++i;
}
AQUALUNG_MUTEX_LOCK(cdda_mutex)
for (i = 0; i < CDDA_DRIVES_MAX; i++) {
if (cdda_drives[i].cdio != NULL) {
cdio_destroy(cdda_drives[i].cdio);
memset(cdda_drives + i, 0, sizeof(cdda_drive_t));
}
}
AQUALUNG_MUTEX_UNLOCK(cdda_mutex)
return NULL;
}
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;
}
static void
oops(const char *psz_msg, int rc)
{
cdio_destroy (p_cdio);
free (psz_device);
exit (rc);
}
void CDIODestroyTimer::setInstance( CdIo_t *cdio, const QString &device, unsigned discID )
{
if ( tryLock() )
emit startTimerSig( cdio, device, discID );
else
cdio_destroy( cdio );
}
CDIODestroyTimer::~CDIODestroyTimer()
{
lock();
if ( timerID )
cdio_destroy( cdio );
unlock();
}
void CDIODestroyTimer::startTimerSlot( CdIo_t *cdio, const QString &device, unsigned discID )
{
if ( timerID )
{
cdio_destroy( this->cdio );
timerID = 0;
}
if ( !( timerID = startTimer( 2500 ) ) )
cdio_destroy( cdio );
else
{
this->cdio = cdio;
this->device = device;
this->discID = discID;
}
unlock();
}
char *libunieject_defaultdevice()
{
CdIo_t *cdio = cdio_open(NULL, DRIVER_UNKNOWN);
char *device = cdio_get_default_device(cdio);
cdio_destroy(cdio);
return device;
}
static void
CDImage_dealloc(cdio_CDImage* self) {
if (self->image != NULL)
cdio_destroy(self->image);
Py_XDECREF(self->pcm_module);
self->ob_type->tp_free((PyObject*)self);
}
/*!
Eject media in CD drive if there is a routine to do so.
@param p_cdio the CD object to be acted upon.
If the CD is ejected *p_cdio is freed and p_cdio set to NULL.
*/
driver_return_code_t
cdio_eject_media (CdIo_t **pp_cdio)
{
if ((pp_cdio == NULL) || (*pp_cdio == NULL)) return DRIVER_OP_UNINIT;
if ((*pp_cdio)->op.eject_media) {
int ret = (*pp_cdio)->op.eject_media ((*pp_cdio)->env);
if (0 == ret) {
cdio_destroy(*pp_cdio);
*pp_cdio = NULL;
}
return ret;
} else {
cdio_destroy(*pp_cdio);
*pp_cdio = NULL;
return DRIVER_OP_UNSUPPORTED;
}
}
void CDIntfDone(void)
{
WriteLog("CDINTF: Shutting down CD-ROM subsystem.\n");
#ifdef HAVE_LIB_CDIO
if (cdioPtr)
cdio_destroy(cdioPtr);
#endif
}
static void
cleanup_thread_params (struct cddb_thread_params *params)
{
int i;
for (i = 0; params->items[i]; i++)
deadbeef->pl_item_unref (params->items[i]);
cdio_destroy (params->cdio);
free (params);
}
static void
cddb_thread (void *items_i)
{
struct cddb_thread_params *params = (struct cddb_thread_params*)items_i;
DB_playItem_t **items = params->items;
trace ("calling resolve_disc\n");
cddb_disc_t* disc = resolve_disc (params->cdio);
if (!disc)
{
trace ("disc not resolved\n");
if (params->cdio) {
cdio_destroy (params->cdio);
}
free (params);
return;
}
trace ("disc resolved\n");
const char *disc_title = cddb_disc_get_title (disc);
const char *artist = cddb_disc_get_artist (disc);
trace ("disc_title=%s, disk_artist=%s\n", disc_title, artist);
cddb_track_t *track;
int i;
// FIXME: playlist must be locked before doing that
int trk = 1;
for (i = 0, track = cddb_disc_get_track_first (disc); items[i]; trk++, ++i, track = cddb_disc_get_track_next (disc))
{
// FIXME: problem will happen here if item(s) were deleted from playlist, and new items were added in their places
// possible solutions: catch EV_TRACKDELETED and mark item(s) in every thread as NULL
trace ("track %d, artist=%s, album=%s, title=%s\n", i, artist, disc_title, cddb_track_get_title (track));
deadbeef->pl_delete_all_meta (items[i]);
deadbeef->pl_add_meta (items[i], "artist", artist);
deadbeef->pl_add_meta (items[i], "album", disc_title);
deadbeef->pl_add_meta (items[i], "title", cddb_track_get_title (track));
char tmp[5];
snprintf (tmp, sizeof (tmp), "%02d", trk);
deadbeef->pl_add_meta (items[i], "track", tmp);
ddb_event_track_t *ev = (ddb_event_track_t *)deadbeef->event_alloc (DB_EV_TRACKINFOCHANGED);
ev->track = items[i];
if (ev->track) {
deadbeef->pl_item_ref (ev->track);
}
deadbeef->event_send ((ddb_event_t *)ev, 0, 0);
}
cddb_disc_destroy (disc);
cleanup_thread_params (params);
ddb_playlist_t *plt = deadbeef->plt_get_curr ();
if (plt) {
deadbeef->plt_modified (plt);
deadbeef->plt_unref (plt);
}
deadbeef->sendmessage (DB_EV_PLAYLISTCHANGED, 0, 0, 0);
}
/*!
Eject media in CD drive if there is a routine to do so.
Return 0 if success and 1 for failure, and 2 if no routine.
If the CD is ejected *obj is freed and obj set to NULL.
*/
int
cdio_eject_media (CdIo **obj)
{
if ((obj == NULL) || (*obj == NULL)) return 1;
if ((*obj)->op.eject_media) {
int ret = (*obj)->op.eject_media ((*obj)->env);
if (0 == ret) {
cdio_destroy(*obj);
*obj = NULL;
}
return ret;
} else {
cdio_destroy(*obj);
*obj = NULL;
return 2;
}
}
static void
cda_free (DB_fileinfo_t *_info)
{
if (_info) {
cdda_info_t *info = (cdda_info_t *)_info;
if (info->cdio) {
cdio_destroy (info->cdio);
}
free (_info);
}
}
static void close_vcd(bgav_input_context_t * ctx)
{
vcd_priv * priv;
priv = ctx->priv;
if(priv->cdio)
cdio_destroy(priv->cdio);
if(priv->tracks)
free(priv->tracks);
free(priv);
return;
}
void
cdda_record__do_eject(cdda_drive_t * drive) {
CdIo_t * cdio = cdio_open(drive->device_path, DRIVER_DEVICE);
if (cdio) {
cdio_eject_media(&cdio);
if (cdio != NULL) {
cdio_destroy(cdio);
}
}
}
/*!
Closes d and releases all storage associated with it.
Doubles as "cdrom_drive_free()".
@param d cdrom_drive_t object to be closed.
@return 0 if passed a null pointer and 1 if not in which case
some work was probably done.
@see cdio_cddap_close_no_free_cdio
*/
int
cdio_cddap_close(cdrom_drive_t *d)
{
if (d) {
CdIo_t *p_cdio = d->p_cdio;
cdio_cddap_close_no_free_cdio(d);
cdio_destroy (p_cdio);
return 1;
}
return 0;
}
void CDIODestroyTimer::timerEvent( QTimerEvent *e )
{
lock();
if ( e->timerId() == timerID )
{
cdio_destroy( cdio );
timerID = 0;
}
killTimer( e->timerId() );
unlock();
}
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
char **ppsz_drives=NULL;
int n=0;
cdio_loglevel_default = (argc > 1) ? CDIO_LOG_DEBUG : CDIO_LOG_INFO;
/* snprintf(psz_nrgfile, sizeof(psz_nrgfile)-1,
"%s/%s", TEST_DIR, cue_file[i]);
*/
if (!cdio_have_driver(DRIVER_OSX)) return(77);
ppsz_drives = cdio_get_devices(DRIVER_DEVICE);
if (!ppsz_drives) {
printf("Can't find a CD-ROM drive. Skipping test.\n");
exit(77);
}
do {
p_cdio = cdio_open_osx(ppsz_drives[n]);
if (p_cdio) {
const char *psz_source = cdio_get_arg(p_cdio, "source");
const char *psz_access_mode = cdio_get_arg(p_cdio, "access-mode");
discmode_t discmode = cdio_get_discmode(p_cdio);
if (0 != strncmp(psz_source, ppsz_drives[0],
strlen(ppsz_drives[0]))) {
fprintf(stderr,
"Got %s; should get back %s, the name we opened.\n",
psz_source, ppsz_drives[0]);
exit(1);
}
if (0 != strncmp(psz_access_mode, "OS X", strlen("OS X"))) {
fprintf(stderr,
"Got %s; Should get back %s, the access mode requested.\n",
psz_access_mode, "OS X");
exit(2);
}
if (CDIO_DISC_MODE_ERROR == discmode) {
fprintf(stderr,
"Error getting disc mode for device %s.\n",
ppsz_drives[n]);
exit(3);
}
}
cdio_destroy(p_cdio);
}
while (ppsz_drives[++n] != NULL);
cdio_free_device_list(ppsz_drives);
return 0;
}
int
main(int argc, const char *argv[])
{
CdIo_t *cdObj;
track_t i_track;
lsn_t lsn;
cdio_log_set_handler (log_handler);
if (cdio_have_driver(DRIVER_BINCUE)) {
cdObj = cdio_open(DATA_DIR "/cdda.cue", DRIVER_UNKNOWN);
} else if (cdio_have_driver(DRIVER_CDRDAO)) {
cdObj = cdio_open(DATA_DIR "/cdda.toc", DRIVER_UNKNOWN);
} else {
printf("-- You don't have enough drivers for this test\n");
return 77;
}
i_track = cdio_get_track(cdObj, 1000);
if (i_track != CDIO_INVALID_TRACK) {
printf("LSN 1000 is too large should have gotten CDIO_INVALID_TRACK back\n");
return 1;
}
for(lsn=0; lsn<10; lsn++) {
i_track = cdio_get_track(cdObj, lsn);
if (i_track != 1) {
printf("LSN %d should return 1. Got %d\n", lsn, i_track);
return 3;
}
}
i_track = cdio_get_track(cdObj, 302);
if (i_track != CDIO_CDROM_LEADOUT_TRACK) {
printf("LSN %d should return leadout. Got %d\n", 302, i_track);
return 4;
}
for(lsn=301; lsn > 300; lsn--) {
i_track = cdio_get_track(cdObj, lsn);
if (i_track != 1) {
printf("LSN %d should return 1. Got %d\n", lsn, i_track);
return 4;
}
}
cdio_destroy(cdObj);
return 0;
}
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
const char *psz_drive = NULL;
if (argc > 1) psz_drive = argv[1];
p_cdio = cdio_open (psz_drive, DRIVER_UNKNOWN);
if (NULL == p_cdio) {
printf("Couldn't find CD\n");
return 1;
} else {
int i_status; /* Result of MMC command */
char buf[36] = { 0, }; /* Place to hold returned data */
mmc_cdb_t cdb = {{0, }}; /* Command Descriptor Buffer */
CDIO_MMC_SET_COMMAND(cdb.field, CDIO_MMC_GPCMD_INQUIRY);
cdb.field[4] = sizeof(buf);
i_status = mmc_run_cmd(p_cdio, DEFAULT_TIMEOUT_MS, &cdb,
SCSI_MMC_DATA_READ, sizeof(buf), &buf);
if (i_status == 0) {
char psz_vendor[CDIO_MMC_HW_VENDOR_LEN+1];
char psz_model[CDIO_MMC_HW_MODEL_LEN+1];
char psz_rev[CDIO_MMC_HW_REVISION_LEN+1];
memcpy(psz_vendor, buf + 8, sizeof(psz_vendor)-1);
psz_vendor[sizeof(psz_vendor)-1] = '\0';
memcpy(psz_model,
buf + 8 + CDIO_MMC_HW_VENDOR_LEN,
sizeof(psz_model)-1);
psz_model[sizeof(psz_model)-1] = '\0';
memcpy(psz_rev,
buf + 8 + CDIO_MMC_HW_VENDOR_LEN +CDIO_MMC_HW_MODEL_LEN,
sizeof(psz_rev)-1);
psz_rev[sizeof(psz_rev)-1] = '\0';
printf("Vendor: %s\nModel: %s\nRevision: %s\n",
psz_vendor, psz_model, psz_rev);
} else {
printf("Couldn't get INQUIRY data (vendor, model, and revision).\n");
}
}
cdio_destroy(p_cdio);
return 0;
}
/*!
Close UDF and free resources associated with p_udf.
*/
bool
udf_close (udf_t *p_udf)
{
if (!p_udf) return true;
if (p_udf->b_stream) {
cdio_stdio_destroy(p_udf->stream);
} else {
cdio_destroy(p_udf->cdio);
}
/* Get rid of root directory if allocated. */
free_and_null(p_udf);
return true;
}
