bool RipTrack(track_t i_track, std::string filename) {
InitWavWriter(filename);
p = cdio_paranoia_init(d);
if (!p) return false;
/* Restrict speed */
if (cdda_speed_set(d, MAX_SPEED) != DRIVER_OP_SUCCESS) {
printf("Unable to set speed\n");
}
i_first_lsn = cdio_cddap_track_firstsector(d, i_track);
if ( -1 == i_first_lsn ) {
printf("Trouble getting starting LSN\n");
} else {
i_last_lsn = cdio_cddap_track_lastsector(d, i_track);
printf("Reading track %d from LSN %ld to LSN %ld\n", i_track,
(long int) i_first_lsn, (long int) i_last_lsn);
/* Set reading mode for full paranoia, but allow skipping sectors. */
paranoia_modeset(p, PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP);
if (RipAttempt() == 1) {
printf("Ripping failed\n");
return false;
}
}
CloseWavWriter();
cdio_paranoia_free(p);
return true;
}
static int
CDDA_init(cdio_CDDAObject *self, PyObject *args, PyObject *kwds)
{
const char *drive = NULL;
self->pcm_module = NULL;
if (!PyArg_ParseTuple(args, "s", &drive))
return -1;
if ((self->pcm_module = PyImport_ImportModule("audiotools.pcm")) == NULL)
return -1;
self->cdrom_drive = cdio_cddap_identify(drive, 0, NULL);
if (self->cdrom_drive == NULL) {
PyErr_SetString(PyExc_IOError,
"error opening CD-ROM");
return -1;
}
if (0 != cdio_cddap_open(self->cdrom_drive)) {
PyErr_SetString(PyExc_IOError,
"error opening CD-ROM");
return -1;
}
self->paranoia = cdio_paranoia_init(self->cdrom_drive);
paranoia_modeset(self->paranoia,
PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP);
return 0;
}
static void device_open(ripncode_t *r)
{
char *msg = NULL;
r->cdio = cdio_open(r->device, driver_id(r));
if (r->cdio == NULL)
ripncode_fatal(r, "failed to open CdIo device '%s' with driver '%s'",
r->device, r->driver);
r->cdda = cdio_cddap_identify_cdio(r->cdio, CDDA_MESSAGE_LOGIT, &msg);
if (r->cdda == NULL)
ripncode_fatal(r, "failed to identify CDDA device '%s' (%s)", r->device,
msg ? msg : "unknown error");
cdio_cddap_free_messages(msg);
if (cdio_cddap_open(r->cdda) < 0)
ripncode_fatal(r, "failed to open CDDA device '%s' (%d: %s)", r->device,
errno, strerror(errno));
r->cdpa = cdio_paranoia_init(r->cdda);
if (r->cdpa == NULL)
ripncode_fatal(r, "failed to open CD-Paranoia device '%s'", r->device);
r->endian = data_bigendianp(r->cdda);
ripncode_info(r, "Drive endianness: %d\n", r->endian);
}
bool CdParanoia::init()
{
free();
#ifdef CDIOPARANOIA_FOUND
drive = cdda_identify(dev.toLatin1().data(), 0, 0);
#else
drive = cdda_identify(dev.toLatin1().data(), 0, 0);
#endif
if (!drive) {
return false;
}
#ifdef CDIOPARANOIA_FOUND
cdio_cddap_open(drive);
paranoia = cdio_paranoia_init(drive);
#else
cdda_open(drive);
paranoia = paranoia_init(drive);
#endif
if (paranoia == 0) {
free();
return false;
}
return true;
}
static av_cold int read_header(AVFormatContext *ctx)
{
CDIOContext *s = ctx->priv_data;
AVStream *st;
int ret, i;
char *err = NULL;
if (!(st = avformat_new_stream(ctx, NULL)))
return AVERROR(ENOMEM);
s->drive = cdio_cddap_identify(ctx->filename, CDDA_MESSAGE_LOGIT, &err);
if (!s->drive) {
av_log(ctx, AV_LOG_ERROR, "Could not open drive %s.\n", ctx->filename);
return AVERROR(EINVAL);
}
if (err) {
av_log(ctx, AV_LOG_VERBOSE, "%s\n", err);
free(err);
}
if ((ret = cdio_cddap_open(s->drive)) < 0 || !s->drive->opened) {
av_log(ctx, AV_LOG_ERROR, "Could not open disk in drive %s.\n", ctx->filename);
return AVERROR(EINVAL);
}
cdio_cddap_verbose_set(s->drive, CDDA_MESSAGE_LOGIT, CDDA_MESSAGE_LOGIT);
if (s->speed)
cdio_cddap_speed_set(s->drive, s->speed);
s->paranoia = cdio_paranoia_init(s->drive);
if (!s->paranoia) {
av_log(ctx, AV_LOG_ERROR, "Could not init paranoia.\n");
return AVERROR(EINVAL);
}
cdio_paranoia_modeset(s->paranoia, s->paranoia_mode);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
if (s->drive->bigendianp)
st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
else
st->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
st->codec->sample_rate = 44100;
st->codec->channels = 2;
if (s->drive->audio_last_sector != CDIO_INVALID_LSN &&
s->drive->audio_first_sector != CDIO_INVALID_LSN)
st->duration = s->drive->audio_last_sector - s->drive->audio_first_sector;
else if (s->drive->tracks)
st->duration = s->drive->disc_toc[s->drive->tracks].dwStartSector;
avpriv_set_pts_info(st, 64, CDIO_CD_FRAMESIZE_RAW, 2*st->codec->channels*st->codec->sample_rate);
for (i = 0; i < s->drive->tracks; i++) {
char title[16];
snprintf(title, sizeof(title), "track %02d", s->drive->disc_toc[i].bTrack);
avpriv_new_chapter(ctx, i, st->time_base, s->drive->disc_toc[i].dwStartSector,
s->drive->disc_toc[i+1].dwStartSector, title);
}
s->last_sector = cdio_cddap_disc_lastsector(s->drive);
return 0;
}
ParanoiaReaderImpl::ParanoiaReaderImpl(Cdda::SharedPtr audio_cd, int max_retries, int mode)
: AudioReader(),
_audio_cd(),
_max_retries(max_retries), // 20
_mode(mode), // PARANOIA_MODE_FULL ^ PARANOIA_MODE_NEVERSKIP
_cdrom_paranoia(NULL)
{
_audio_cd = orion::iface_cast<CddaImpl>(audio_cd);
_cdrom_paranoia = cdio_paranoia_init(_audio_cd->cdrom());
}
static int cdpa_open(rnc_dev_t *dev, const char *device)
{
cdpa_t *cdpa;
char *msg;
mrp_debug("opening device '%s' with cdparanoia", device);
msg = NULL;
cdpa = dev->data = mrp_allocz(sizeof(*cdpa));
if (cdpa == NULL)
goto fail;
cdpa->cdio = cdio_open(device, DRIVER_LINUX);
if (cdpa->cdio == NULL) {
msg = "failed open device";
goto fail;
}
cdpa->cdda = cdio_cddap_identify_cdio(cdpa->cdio, CDDA_MESSAGE_LOGIT, &msg);
if (cdpa->cdda == NULL)
goto fail;
cdio_cddap_free_messages(msg);
msg = NULL;
if (cdio_cddap_open(cdpa->cdda) < 0) {
msg = "failed to CDDAP-open device";
goto fail;
}
cdpa->cdpa = cdio_paranoia_init(cdpa->cdda);
if (cdpa->cdpa == NULL) {
msg = "failed to initialize cd-paranoia";
goto fail;
}
cdpa->ctrack = -1;
return 0;
fail:
if (cdpa != NULL && msg != NULL)
cdpa->errmsg = mrp_strdup(msg);
return -1;
}
static int
CDDAReader_init_device(cdio_CDDAReader *self, const char *device)
{
self->_.drive.drive = NULL;
self->_.drive.paranoia = NULL;
self->_.drive.current_sector = 0;
self->_.drive.final_sector = 0;
if ((self->_.drive.drive = cdio_cddap_identify(device, 0, NULL)) == NULL) {
PyErr_SetString(PyExc_IOError, "error opening CD-ROM");
return -1;
}
if (cdio_cddap_open(self->_.drive.drive) != 0) {
PyErr_SetString(PyExc_IOError, "error opening CD-ROM");
return -1;
}
self->_.drive.paranoia = cdio_paranoia_init(self->_.drive.drive);
paranoia_modeset(self->_.drive.paranoia,
PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP);
self->first_track_num = CDDAReader_first_track_num_device;
self->last_track_num = CDDAReader_last_track_num_device;
self->track_lsn = CDDAReader_track_lsn_device;
self->track_last_lsn = CDDAReader_track_last_lsn_device;
self->first_sector = CDDAReader_first_sector_device;
self->last_sector = CDDAReader_last_sector_device;
self->read = CDDAReader_read_device;
self->seek = CDDAReader_seek_device;
self->set_speed = CDDAReader_set_speed_device;
self->dealloc = CDDAReader_dealloc_device;
self->_.drive.final_sector = self->last_sector(self);
if ((self->_.drive.final_sector == -1) ||
(self->first_sector(self) == -1)) {
PyErr_SetString(PyExc_IOError, "no disc in CD-ROM drive");
return -1;
}
return 0;
}
static void cued_rip_prologue(rip_context_t *rip)
{
rip->mmcBuf = NULL;
rip->allocatedSectors = 0;
#ifdef CUED_HAVE_PARANOIA
if (ripUseParanoia) {
char *msg = 0;
int rc;
// N.B. this behavior does not match documentation:
// the 0 here appears to prevent the message "Checking <filename> for cdrom..."
rip->paranoiaCtlObj = cdio_cddap_identify_cdio(rip->cdObj, 0, &msg);
if (rip->paranoiaCtlObj) {
if (msg) {
cdio_warn("identify returned paranoia message(s) \"%s\"", msg);
}
cdio_cddap_verbose_set(rip->paranoiaCtlObj, CDDA_MESSAGE_LOGIT, CDDA_MESSAGE_LOGIT);
rc = cdio_cddap_open(rip->paranoiaCtlObj);
cdio2_paranoia_msg(rip->paranoiaCtlObj, "open of device");
if (!rc) {
rip->paranoiaRipObj = cdio_paranoia_init(rip->paranoiaCtlObj);
cdio2_paranoia_msg(rip->paranoiaCtlObj, "initialization of paranoia");
if (!rip->paranoiaRipObj) {
cdio2_abort("out of memory initializing paranoia");
}
cdio_paranoia_modeset(rip->paranoiaRipObj, PARANOIA_MODE_FULL ^ PARANOIA_MODE_NEVERSKIP);
// N.B. not needed at the moment
cdio2_paranoia_msg(rip->paranoiaCtlObj, "setting of paranoia mode");
rip->save_read_paranoid = rip->paranoiaCtlObj->read_audio;
rip->paranoiaCtlObj->read_audio = cued_read_paranoid;
} else {
cdio_cddap_close_no_free_cdio(rip->paranoiaCtlObj);
cdio_error("disabling paranoia");
CLRF(RIP_F_USE_PARANOIA, rip->flags);
}
} else {
cdio_error("disabling paranoia due to the following message(s):\n%s", msg);
CLRF(RIP_F_USE_PARANOIA, rip->flags);
}
}
#endif // CUED_HAVE_PARANOIA
if (rip->qSubChannelFileName) {
if (!strcmp("-", rip->qSubChannelFileName)) {
rip->qSubChannelFile = stdout;
} else {
(void) format_get_file_path(rip->cdObj, rip->cddbObj, rip->qSubChannelFileName, "", 0, rip->fileNameBuffer, rip->bufferSize);
// replaced O_EXCL with O_TRUNC to allow using /dev/null for testing
rip->qSubChannelFile = fopen2(rip->fileNameBuffer, O_WRONLY | O_CREAT | O_TRUNC | O_APPEND, 0666);
if (!rip->qSubChannelFile) {
cdio2_unix_error("fopen2", rip->fileNameBuffer, 0);
cdio_error("not creating sub-channel file \"%s\"", rip->fileNameBuffer);
rip->qSubChannelFileName = 0;
}
}
}
rip->endOfDiscSector = cdio_get_disc_last_lsn(rip->cdObj);
if (CDIO_INVALID_LSN == rip->endOfDiscSector) {
cdio2_abort("failed to get last sector number");
} else {
//cdio_debug("end of disc sector is %d", rip->endOfDiscSector);
}
}
static struct input_stream *
input_cdio_open(const char *uri,
GMutex *mutex, GCond *cond,
GError **error_r)
{
struct input_cdio_paranoia *i;
struct cdio_uri parsed_uri;
if (!parse_cdio_uri(&parsed_uri, uri, error_r))
return NULL;
i = g_new(struct input_cdio_paranoia, 1);
input_stream_init(&i->base, &input_plugin_cdio_paranoia, uri,
mutex, cond);
/* initialize everything (should be already) */
i->drv = NULL;
i->cdio = NULL;
i->para = NULL;
i->trackno = parsed_uri.track;
pcm_buffer_init(&i->conv_buffer);
/* get list of CD's supporting CD-DA */
char *device = parsed_uri.device[0] != 0
? g_strdup(parsed_uri.device)
: cdio_detect_device();
if (device == NULL) {
g_set_error(error_r, cdio_quark(), 0,
"Unable find or access a CD-ROM drive with an audio CD in it.");
input_cdio_close(&i->base);
return NULL;
}
/* Found such a CD-ROM with a CD-DA loaded. Use the first drive in the list. */
i->cdio = cdio_open(device, DRIVER_UNKNOWN);
g_free(device);
i->drv = cdio_cddap_identify_cdio(i->cdio, 1, NULL);
if ( !i->drv ) {
g_set_error(error_r, cdio_quark(), 0,
"Unable to identify audio CD disc.");
input_cdio_close(&i->base);
return NULL;
}
cdda_verbose_set(i->drv, CDDA_MESSAGE_FORGETIT, CDDA_MESSAGE_FORGETIT);
if ( 0 != cdio_cddap_open(i->drv) ) {
g_set_error(error_r, cdio_quark(), 0, "Unable to open disc.");
input_cdio_close(&i->base);
return NULL;
}
i->endian = data_bigendianp(i->drv);
switch (i->endian) {
case -1:
g_debug("cdda: drive returns unknown audio data, assuming Little Endian");
i->endian = 0;
break;
case 0:
g_debug("cdda: drive returns audio data Little Endian.");
break;
case 1:
g_debug("cdda: drive returns audio data Big Endian.");
break;
default:
g_set_error(error_r, cdio_quark(), 0,
"Drive returns unknown data type %d", i->endian);
input_cdio_close(&i->base);
return NULL;
}
i->lsn_relofs = 0;
if (i->trackno >= 0) {
i->lsn_from = cdio_get_track_lsn(i->cdio, i->trackno);
i->lsn_to = cdio_get_track_last_lsn(i->cdio, i->trackno);
} else {
i->lsn_from = 0;
i->lsn_to = cdio_get_disc_last_lsn(i->cdio);
}
i->para = cdio_paranoia_init(i->drv);
/* Set reading mode for full paranoia, but allow skipping sectors. */
paranoia_modeset(i->para, PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP);
/* seek to beginning of the track */
cdio_paranoia_seek(i->para, i->lsn_from, SEEK_SET);
i->base.ready = true;
i->base.seekable = true;
i->base.size = (i->lsn_to - i->lsn_from + 1) * CDIO_CD_FRAMESIZE_RAW;
/* hack to make MPD select the "pcm" decoder plugin */
i->base.mime = g_strdup("audio/x-mpd-cdda-pcm");
return &i->base;
}
// pure virtual
bool CdDecoder::initialize()
{
if (m_inited)
return true;
m_inited = m_user_stop = m_finish = false;
m_freq = m_bitrate = 0L;
m_stat = DecoderEvent::Error;
m_chan = 0;
m_seekTime = -1.;
if (output())
output()->PauseUntilBuffered();
QFile* file = dynamic_cast< QFile* >(input()); // From QIODevice*
if (file)
{
setFilename(file->fileName());
m_tracknum = getFilename().section('.', 0, 0).toUInt();
}
QMutexLocker lock(&getCdioMutex());
m_cdio = openCdio(m_devicename);
if (!m_cdio)
return false;
m_start = cdio_get_track_lsn(m_cdio, m_tracknum);
m_end = cdio_get_track_last_lsn(m_cdio, m_tracknum);
if (CDIO_INVALID_LSN == m_start ||
CDIO_INVALID_LSN == m_end)
{
LOG(VB_MEDIA, LOG_INFO, "CdDecoder: No tracks on " + m_devicename);
cdio_destroy(m_cdio), m_cdio = 0;
return false;
}
LOG(VB_MEDIA, LOG_DEBUG, QString("CdDecoder track=%1 lsn start=%2 end=%3")
.arg(m_tracknum).arg(m_start).arg(m_end));
m_curpos = m_start;
m_device = cdio_cddap_identify_cdio(m_cdio, 0, NULL);
if (NULL == m_device)
{
LOG(VB_GENERAL, LOG_ERR,
QString("Error: CdDecoder: cdio_cddap_identify(%1) failed")
.arg(m_devicename));
cdio_destroy(m_cdio), m_cdio = 0;
return false;
}
cdio_cddap_verbose_set(m_device,
VERBOSE_LEVEL_CHECK(VB_MEDIA, LOG_ANY) ? CDDA_MESSAGE_PRINTIT :
CDDA_MESSAGE_FORGETIT,
VERBOSE_LEVEL_CHECK(VB_MEDIA, LOG_DEBUG) ? CDDA_MESSAGE_PRINTIT :
CDDA_MESSAGE_FORGETIT);
if (DRIVER_OP_SUCCESS == cdio_cddap_open(m_device))
{
// cdio_get_track_last_lsn is unreliable on discs with data at end
lsn_t end2 = cdio_cddap_track_lastsector(m_device, m_tracknum);
if (end2 < m_end)
{
LOG(VB_MEDIA, LOG_INFO, QString("CdDecoder: trim last lsn from %1 to %2")
.arg(m_end).arg(end2));
m_end = end2;
}
m_paranoia = cdio_paranoia_init(m_device);
if (NULL != m_paranoia)
{
cdio_paranoia_modeset(m_paranoia, PARANOIA_MODE_DISABLE);
(void)cdio_paranoia_seek(m_paranoia, m_start, SEEK_SET);
}
else
{
LOG(VB_GENERAL, LOG_ERR, "Warn: CD reading with paranoia is disabled");
}
}
else
{
LOG(VB_GENERAL, LOG_ERR,
QString("Warn: drive '%1' is not cdda capable").
arg(m_devicename));
}
int chnls = cdio_get_track_channels(m_cdio, m_tracknum);
m_chan = chnls > 0 ? chnls : 2;
m_freq = kSamplesPerSec;
if (output())
{
const AudioSettings settings(FORMAT_S16, m_chan,
CODEC_ID_PCM_S16LE, m_freq, false /* AC3/DTS passthru */);
output()->Reconfigure(settings);
output()->SetSourceBitrate(m_freq * m_chan * 16);
}
// 20ms worth
m_bks = (m_freq * m_chan * 2) / 50;
m_bksFrames = m_freq / 50;
// decode 8 bks worth of samples each time we need more
m_decodeBytes = m_bks << 3;
m_output_buf = reinterpret_cast< char* >(
::av_malloc(m_decodeBytes + CDIO_CD_FRAMESIZE_RAW * 2));
m_output_at = 0;
setCDSpeed(2);
m_inited = true;
return m_inited;
}
