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;
}
