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; }
static gboolean xmms_cdda_plugin_setup (xmms_xform_plugin_t *xform_plugin) { const gchar *device; xmms_xform_methods_t methods; XMMS_XFORM_METHODS_INIT (methods); methods.init = xmms_cdda_init; methods.destroy = xmms_cdda_destroy; methods.read = xmms_cdda_read; methods.seek = xmms_cdda_seek; methods.browse = xmms_cdda_browse; xmms_xform_plugin_methods_set (xform_plugin, &methods); xmms_xform_plugin_indata_add (xform_plugin, XMMS_STREAM_TYPE_MIMETYPE, "application/x-url", XMMS_STREAM_TYPE_URL, "cdda://*", XMMS_STREAM_TYPE_END); device = cdio_get_default_device (NULL); if (!device) { device = ""; } xmms_xform_plugin_config_property_register (xform_plugin, "device", device, NULL, NULL); xmms_xform_plugin_config_property_register (xform_plugin, "accessmode", "default", NULL, NULL); return TRUE; }
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; }
char *libunieject_defaultdevice() { CdIo_t *cdio = cdio_open(NULL, DRIVER_UNKNOWN); char *device = cdio_get_default_device(cdio); cdio_destroy(cdio); return device; }
const uint8 * CDIntfGetDriveName(uint32 driveNum) { #warning "!!! FIX !!! CDIntfGetDriveName driveNum is currently ignored!" // driveNum is currently ignored... !!! FIX !!! #ifdef HAVE_LIB_CDIO uint8 * driveName = (uint8 *)cdio_get_default_device(cdioPtr); WriteLog("CDINTF: The drive name for the current driver is %s.\n", driveName); return driveName; #else return (uint8 *)"NONE"; #endif }
int main(int argc, char **argv) { gtk_init(&argc, &argv); #ifdef LIB_DEBUG cddb_log_set_level(CDDB_LOG_DEBUG); #endif CdIo_t *p_cdio = cdio_open(NULL, DRIVER_DEVICE); device_name = cdio_get_default_device(p_cdio); if (p_cdio == NULL) { fputs("Unable to read the CD drive!\n", stderr); return 1; } ui_loading_screen(); cddb_disc_t *disc = cddb_disc_new(); enum giles_cddb_err get_cddb_info_err = get_cddb_info_for_device(p_cdio, disc); switch (get_cddb_info_err) { case giles_cddb_err_no_conn: fputs("Could not connect to CDDB database.\n", stderr); break; case giles_cddb_err_no_match: fputs("Could not find a match for the CD in the CDDB database.\n", stderr); break; default: break; } cdio_destroy(p_cdio); ui_loading_screen_done(); ui_show_disc_info(disc); gtk_main(); return 0; }
int main(int argc, const char *argv[]) { CdIo_t *p_cdio=NULL; init(); /* Parse our arguments; every option seen by `parse_opt' will be reflected in `arguments'. */ parse_options(argc, argv); print_version(program_name, CDIO_VERSION, false, opts.version_only); if (opts.debug_level == 3) { cdio_loglevel_default = CDIO_LOG_INFO; } else if (opts.debug_level >= 4) { cdio_loglevel_default = CDIO_LOG_DEBUG; } if (NULL == source_name) { char *default_device; p_cdio = cdio_open (NULL, DRIVER_DEVICE); if (NULL == p_cdio) { printf("No loaded CD-ROM device accessible.\n"); } else { default_device = cdio_get_default_device(p_cdio); 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); } free(default_device); cdio_destroy(p_cdio); p_cdio=NULL; printf("\n"); } } /* Print out a drivers available */ { driver_id_t driver_id; printf("Drivers available...\n"); for (driver_id=CDIO_MIN_DRIVER; driver_id<=CDIO_MAX_DRIVER; driver_id++) if (cdio_have_driver(driver_id)) { printf(" %-35s\n", cdio_driver_describe(driver_id)); } printf("\n"); } if (NULL == source_name) { /* Print out a list of CD-drives */ char **ppsz_cdrives=NULL, **ppsz_cd; driver_id_t driver_id = DRIVER_DEVICE; ppsz_cdrives = cdio_get_devices_ret(&driver_id); if (NULL != ppsz_cdrives) for( ppsz_cd = ppsz_cdrives; *ppsz_cd != NULL; ppsz_cd++ ) { cdio_drive_read_cap_t i_read_cap; cdio_drive_write_cap_t i_write_cap; cdio_drive_misc_cap_t i_misc_cap; cdio_hwinfo_t hwinfo; CdIo_t *p_cdio = cdio_open(*ppsz_cd, driver_id); printf("%28s: %s\n", "Drive", *ppsz_cd); if (p_cdio) { if (cdio_get_hwinfo(p_cdio, &hwinfo)) { printf("%-28s: %s\n%-28s: %s\n%-28s: %s\n", "Vendor" , hwinfo.psz_vendor, "Model" , hwinfo.psz_model, "Revision", hwinfo.psz_revision); } print_mmc_drive_features(p_cdio); 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); } printf("\n"); if (p_cdio) cdio_destroy(p_cdio); } cdio_free_device_list(ppsz_cdrives); free(ppsz_cdrives); ppsz_cdrives = NULL; } else { /* Print CD-drive info for given source */ cdio_drive_read_cap_t i_read_cap; cdio_drive_write_cap_t i_write_cap; cdio_drive_misc_cap_t i_misc_cap; cdio_hwinfo_t hwinfo; printf("Drive %s\n", source_name); p_cdio = cdio_open (source_name, DRIVER_UNKNOWN); if (NULL != p_cdio) { if (cdio_get_hwinfo(p_cdio, &hwinfo)) { printf("%-28s: %s\n%-28s: %s\n%-28s: %s\n", "Vendor" , hwinfo.psz_vendor, "Model" , hwinfo.psz_model, "Revision", hwinfo.psz_revision); } print_mmc_drive_features(p_cdio); } cdio_get_drive_cap_dev(source_name, &i_read_cap, &i_write_cap, &i_misc_cap); print_drive_capabilities(i_read_cap, i_write_cap, i_misc_cap); printf("\n"); } myexit(p_cdio, EXIT_SUCCESS); /* Not reached:*/ return(EXIT_SUCCESS); }
/*! Sets up to read from place specified by source_name and driver_id. This should be called before using any other routine, except cdio_init. This will call cdio_init, if that hasn't been done previously. NULL is returned on error. */ CdIo * cdio_open (const char *orig_source_name, driver_id_t driver_id) { char *source_name; if (CdIo_last_driver == -1) cdio_init(); if (NULL == orig_source_name || strlen(orig_source_name)==0) source_name = cdio_get_default_device(NULL); else source_name = strdup(orig_source_name); retry: switch (driver_id) { case DRIVER_UNKNOWN: { CdIo *cdio=scan_for_driver(CDIO_MIN_DRIVER, CDIO_MAX_DRIVER, source_name); if (cdio != NULL && cdio_is_device(source_name, cdio->driver_id)) { driver_id = cdio->driver_id; } else { struct stat buf; if (0 != stat(source_name, &buf)) { return NULL; } if (S_ISREG(buf.st_mode)) { /* FIXME: check to see if is a text file. If so, then set SOURCE_CUE. */ int i=strlen(source_name)-strlen("bin"); if (i > 0 && ( (source_name)[i] =='n' || (source_name)[i] =='N' ) && ( (source_name)[i+1] =='r' || (source_name)[i+1] =='R' ) && ( (source_name)[i+2] =='g' || (source_name)[i+2] =='G' ) ) driver_id = DRIVER_NRG; else if (i > 0 && ( (source_name)[i] =='c' || (source_name)[i] =='C') && ( (source_name)[i+1] =='u' || (source_name)[i+1] =='U') && ( (source_name)[i+2] =='e' || (source_name)[i+2] =='E') ) driver_id = DRIVER_BINCUE; else driver_id = DRIVER_BINCUE; } else { cdio_destroy(cdio); return NULL; } } cdio_destroy(cdio); goto retry; } case DRIVER_DEVICE: { /* Scan for a driver. */ CdIo *ret = cdio_open_cd(source_name); free(source_name); return ret; } break; case DRIVER_BSDI: case DRIVER_FREEBSD: case DRIVER_LINUX: case DRIVER_SOLARIS: case DRIVER_WIN32: case DRIVER_OSX: case DRIVER_NRG: case DRIVER_BINCUE: if ((*CdIo_all_drivers[driver_id].have_driver)()) { CdIo *ret = (*CdIo_all_drivers[driver_id].driver_open)(source_name); if (ret) ret->driver_id = driver_id; return ret; } } free(source_name); return NULL; }
std::string CddaImpl::device_name() const { return cdio_get_default_device(_cdio); }