static int CDDAReader_init_image(cdio_CDDAReader *self, const char *device) { self->_.image.image = NULL; self->_.image.current_sector = 0; self->_.image.final_sector = 0; self->first_track_num = CDDAReader_first_track_num_image; self->last_track_num = CDDAReader_last_track_num_image; self->track_lsn = CDDAReader_track_lsn_image; self->track_last_lsn = CDDAReader_track_last_lsn_image; self->first_sector = CDDAReader_first_sector_image; self->last_sector = CDDAReader_last_sector_image; self->read = CDDAReader_read_image; self->seek = CDDAReader_seek_image; self->set_speed = CDDAReader_set_speed_image; self->dealloc = CDDAReader_dealloc_image; /*open CD image based on what type it is*/ if (cdio_is_cuefile(device)) { self->_.image.image = cdio_open_cue(device); } else if (cdio_is_tocfile(device)) { self->_.image.image = cdio_open_bincue(device); } else if (cdio_is_tocfile(device)) { self->_.image.image = cdio_open_cdrdao(device); } else if (cdio_is_nrg(device)) { self->_.image.image = cdio_open_nrg(device); } if (self->_.image.image == NULL) { PyErr_SetString(PyExc_IOError, "unable to open CD image"); return -1; } self->_.image.final_sector = (lsn_t)self->last_sector(self); return 0; }
static int CDDAReader_init(cdio_CDDAReader *self, PyObject *args, PyObject *kwds) { char *device = NULL; struct stat buf; self->is_cd_image = 0; self->is_logging = 0; self->dealloc = NULL; self->closed = 0; self->audiotools_pcm = NULL; cddareader_reset_log(&(self->log)); if (!PyArg_ParseTuple(args, "s|i", &device, &(self->is_logging))) return -1; if ((self->audiotools_pcm = open_audiotools_pcm()) == NULL) return -1; /*identify whether drive is physical or a CD image*/ if (stat(device, &buf)) { PyErr_SetFromErrno(PyExc_IOError); return -1; } if (S_ISREG(buf.st_mode)) { if (cdio_is_cuefile(device) || cdio_is_binfile(device) || cdio_is_tocfile(device) || cdio_is_nrg(device)) { /*open CD image and set function pointers*/ self->is_cd_image = 1; self->is_logging = 0; return CDDAReader_init_image(self, device); } else { /*unsupported file*/ PyErr_SetString(PyExc_ValueError, "unsupported CD image type"); return -1; } } else if (S_ISBLK(buf.st_mode)) { if (cdio_is_device(device, DRIVER_LINUX)) { /*open CD device and set function pointers*/ self->is_cd_image = 0; return CDDAReader_init_device(self, device); } else { /*unsupported block device*/ PyErr_SetString(PyExc_ValueError, "unsupported block device"); return -1; } } else { /*unsupported file type*/ PyErr_SetString(PyExc_ValueError, "unsupported file type"); return -1; } }
static PyObject* cdio_identify_cdrom(PyObject *dummy, PyObject *args) { const char* device; struct stat buf; if (!PyArg_ParseTuple(args, "s", &device)) return NULL; if (stat(device, &buf)) { PyErr_SetFromErrno(PyExc_IOError); return NULL; } if (S_ISREG(buf.st_mode)) { if (cdio_is_cuefile(device)) { return Py_BuildValue("i", CD_IMAGE | CUE_FILE); } else if (cdio_is_binfile(device)) { return Py_BuildValue("i", CD_IMAGE | BIN_FILE); } else if (cdio_is_tocfile(device)) { return Py_BuildValue("i", CD_IMAGE | TOC_FILE); } else if (cdio_is_nrg(device)) { return Py_BuildValue("i", CD_IMAGE | NRG_FILE); } else { PyErr_SetString(PyExc_ValueError, "unknown image file"); return NULL; } } else if (S_ISBLK(buf.st_mode)) { if (cdio_is_device(device, DRIVER_LINUX)) { return Py_BuildValue("i", DEVICE_FILE); } else { PyErr_SetString(PyExc_ValueError, "unknown CD device"); return NULL; } } else { PyErr_SetString(PyExc_ValueError, "unknown device"); return NULL; } }
/*! Determine if psz_toc is a TOC file for a cdrdao CD disk image. @param psz_toc location of presumed TOC image file. @return true if toc_name is a cdrdao TOC file or false if not a TOC file. */ bool isTocFile(const char *psz_toc) { return cdio_is_tocfile(psz_toc); }
/*! Initialization routine. This is the only thing that doesn't get called via a function pointer. In fact *we* are the ones to set that up. */ CdIo_t * cdio_open_cdrdao (const char *psz_cue_name) { CdIo_t *ret; _img_private_t *p_data; cdio_funcs_t _funcs; memset( &_funcs, 0, sizeof(_funcs) ); _funcs.eject_media = _eject_media_image; _funcs.free = _free_image; _funcs.get_arg = _get_arg_image; _funcs.get_cdtext = _get_cdtext_image; _funcs.get_cdtext_raw = NULL; _funcs.get_devices = cdio_get_devices_cdrdao; _funcs.get_default_device = cdio_get_default_device_cdrdao; _funcs.get_disc_last_lsn = get_disc_last_lsn_cdrdao; _funcs.get_discmode = _get_discmode_image; _funcs.get_drive_cap = _get_drive_cap_image; _funcs.get_first_track_num = _get_first_track_num_image; _funcs.get_hwinfo = get_hwinfo_cdrdao; _funcs.get_media_changed = get_media_changed_image; _funcs.get_mcn = _get_mcn_image; _funcs.get_num_tracks = _get_num_tracks_image; _funcs.get_track_channels = get_track_channels_image; _funcs.get_track_copy_permit = get_track_copy_permit_image; _funcs.get_track_format = _get_track_format_cdrdao; _funcs.get_track_green = _get_track_green_cdrdao; _funcs.get_track_lba = _get_lba_track_cdrdao; _funcs.get_track_msf = _get_track_msf_image; _funcs.get_track_preemphasis = get_track_preemphasis_image; _funcs.get_track_pregap_lba = get_track_pregap_lba_image; _funcs.get_track_isrc = get_track_isrc_image; _funcs.lseek = _lseek_cdrdao; _funcs.read = _read_cdrdao; _funcs.read_audio_sectors = _read_audio_sectors_cdrdao; _funcs.read_data_sectors = read_data_sectors_image; _funcs.read_mode1_sector = _read_mode1_sector_cdrdao; _funcs.read_mode1_sectors = _read_mode1_sectors_cdrdao; _funcs.read_mode2_sector = _read_mode2_sector_cdrdao; _funcs.read_mode2_sectors = _read_mode2_sectors_cdrdao; _funcs.run_mmc_cmd = NULL; _funcs.set_arg = _set_arg_image; _funcs.set_speed = cdio_generic_unimplemented_set_speed; _funcs.set_blocksize = cdio_generic_unimplemented_set_blocksize; if (NULL == psz_cue_name) return NULL; p_data = calloc(1, sizeof (_img_private_t)); p_data->gen.init = false; p_data->psz_cue_name = NULL; p_data->gen.data_source = NULL; p_data->gen.source_name = NULL; ret = cdio_new ((void *)p_data, &_funcs); if (ret == NULL) { free(p_data); return NULL; } ret->driver_id = DRIVER_CDRDAO; if (!cdio_is_tocfile(psz_cue_name)) { cdio_debug ("source name %s is not recognized as a TOC file", psz_cue_name); free(p_data); free(ret); return NULL; } _set_arg_image (p_data, "cue", psz_cue_name); _set_arg_image (p_data, "source", psz_cue_name); _set_arg_image (p_data, "access-mode", "cdrdao"); if (_init_cdrdao(p_data)) { return ret; } else { _free_image(p_data); free(ret); return NULL; } }
int main(int argc, const char *argv[]) { const char *toc_file[NUM_GOOD_TOCS] = { "cdtext.toc", "t1.toc", "t2.toc", "t3.toc", "t4.toc", "t5.toc", "t6.toc", "t7.toc", "t8.toc", "t9.toc", "t10.toc", "data1.toc", "data2.toc", "data5.toc", "data6.toc", "data7.toc", "vcd2.toc", }; const char *badtoc_file[NUM_BAD_TOCS] = { "bad-msf-1.toc", "bad-msf-2.toc", "bad-msf-3.toc", "bad-cat1.toc", "bad-cat2.toc", "bad-cat3.toc", "bad-file.toc", "bad-mode1.toc" }; int ret=0; unsigned int i; char psz_tocfile[500]; unsigned int verbose = (argc > 1); #ifdef HAVE_CHDIR if (0 == chdir(DATA_DIR)) #endif { psz_tocfile[sizeof(psz_tocfile)-1] = '\0'; cdio_loglevel_default = verbose ? CDIO_LOG_DEBUG : CDIO_LOG_WARN; for (i=0; i<NUM_GOOD_TOCS; i++) { CdIo_t *p_cdio; snprintf(psz_tocfile, sizeof(psz_tocfile)-1, "%s/%s", DATA_DIR, toc_file[i]); if (!cdio_is_tocfile(psz_tocfile) || !(p_cdio = cdio_open_cdrdao(psz_tocfile))) { fprintf(stderr, "Incorrect: %s doesn't parse as a cdrdao TOC file.\n", toc_file[i]); ret=i+1; } else { cdio_destroy(p_cdio); if (verbose) printf("Correct: %s parses as a cdrdao TOC file.\n", toc_file[i]); } } for (i=0; i<NUM_BAD_TOCS; i++) { snprintf(psz_tocfile, sizeof(psz_tocfile)-1, "%s/%s", DATA_DIR, badtoc_file[i]); if (!cdio_is_tocfile(psz_tocfile)) { if (verbose) printf("Correct: %s doesn't parse as a cdrdao TOC file.\n", badtoc_file[i]); } else { fprintf(stderr, "Incorrect: %s parses as a cdrdao TOC file.\n", badtoc_file[i]); ret+=50*i+1; break; } } /* { CdIo_t *p_cdio; snprintf(psz_tocfile, sizeof(psz_tocfile)-1, "%s/%s", DATA_DIR, "cdda.toc"); p_cdio = cdio_open (psz_tocfile, DRIVER_CDRDAO); if (!p_cdio) { fprintf(stderr, "Can't open %s as a cdrdao TOC file.\n", psz_tocfile); exit(5); } check_mmc_supported(p_cdio, 1); check_access_mode(p_cdio, "image"); check_get_arg_source(p_cdio, psz_tocfile); cdio_destroy(p_cdio); } */ } return ret; }