/*! */ long ParanoiaReaderImpl::read(uint8_t* buffer, uint32_t begin_sector, uint32_t sectors) { if (not _audio_cd->is_open()) { THROW_EXCEPTION(CddaException, "AudioCd is closed"); } cdio_paranoia_modeset(_cdrom_paranoia, PARANOIA_MODE_FULL ^ PARANOIA_MODE_NEVERSKIP); cdio_paranoia_seek(_cdrom_paranoia, begin_sector, SEEK_SET); int16_t* read_buffer = cdio_paranoia_read_limited(_cdrom_paranoia, NULL, _max_retries); //! \todo Use another system to free returned messages char* err = cdio_cddap_errors(_audio_cd->cdrom()); //char* mes = cdio_cddap_messages(_audio_cd->cdrom()); if (err) { std::string tmp = err; delete [] err; THROW_EXCEPTION(CddaException, tmp); } buffer = reinterpret_cast<uint8_t*>(read_buffer); return sectors; }
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; }
void CdParanoia::setParanoiaMode(int mode) { // from cdrdao 1.1.7 paranoiaMode = PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP; switch (mode) { case 0: paranoiaMode = PARANOIA_MODE_DISABLE; break; case 1: paranoiaMode |= PARANOIA_MODE_OVERLAP; paranoiaMode &= ~PARANOIA_MODE_VERIFY; break; case 2: paranoiaMode &= ~(PARANOIA_MODE_SCRATCH|PARANOIA_MODE_REPAIR); break; } if (neverSkip) { paranoiaMode |= PARANOIA_MODE_NEVERSKIP; } if (paranoia) { #ifdef CDIOPARANOIA_FOUND cdio_paranoia_modeset(paranoia, paranoiaMode); #else paranoia_modeset(paranoia, paranoiaMode); #endif } }
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 int cdpa_get_tracks(rnc_dev_t *dev, rnc_track_t *buf, size_t size) { cdpa_t *cdpa = dev->data; cdpa_track_t *tracks, *trk; int ntrack, base, naudio; rnc_track_t *t; int id, i; mrp_debug("getting tracks"); base = cdio_get_first_track_num(cdpa->cdio); if (cdpa->ntrack == 0) { ntrack = cdio_get_num_tracks(cdpa->cdio); if (ntrack == 0) return 0; tracks = mrp_allocz_array(typeof(*tracks), ntrack); if (tracks == NULL) return -1; naudio = 0; trk = tracks; for (i = 0; i < ntrack; i++) { id = base + i; if (cdio_get_track_format(cdpa->cdio, id) != TRACK_FORMAT_AUDIO) continue; trk->id = id; trk->idx = i; trk->fblk = cdio_get_track_lsn(cdpa->cdio, id); trk->lblk = cdio_get_track_last_lsn(cdpa->cdio, id); naudio++; trk++; } cdpa->tracks = tracks; cdpa->ntrack = naudio; } else ntrack = cdpa->ntrack; if ((int)size > cdpa->ntrack) size = cdpa->ntrack; for (i = 0, t = buf, trk = cdpa->tracks; i < (int)size; i++, t++, trk++) { t->idx = trk - cdpa->tracks; t->id = base + i; t->fblk = trk->fblk; t->nblk = trk->lblk - trk->fblk + 1; t->length = 1.0 * t->nblk / 75.0; } if (cdpa->ctrack < 0) { cdio_paranoia_modeset(cdpa->cdpa, PARANOIA_MODE_FULL); cdpa->ctrack = 0; seek_track(cdpa, 0, 0); } return ntrack; }
// 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; }
static void get_track_info(ripncode_t *r) { rip_track_t *t; int i, base; char file[1024], *msg; int16_t *samples; int fd, n, l, total; base = cdio_get_first_track_num(r->cdio); r->ntrack = cdio_get_num_tracks(r->cdio); r->tracks = mrp_allocz_array(rip_track_t, r->ntrack); if (r->tracks == NULL && r->ntrack > 0) ripncode_fatal(r, "failed to allocate track info"); cdio_paranoia_modeset(r->cdpa, PARANOIA_MODE_FULL); for (i = 0, t = r->tracks; i < r->ntrack; i++, t++) { if (i >= r->last) break; t->id = base + i; t->format = cdio_get_track_format(r->cdio, base + i); t->lsn_beg = cdio_get_track_lsn(r->cdio, base + i); t->lsn_end = cdio_get_track_last_lsn(r->cdio, base + i); t->lba = cdio_get_track_lba(r->cdio, base + i); printf("track #%d (id %d): lsn: %u - %u (lba %u), format: %s\n", i, base + i, t->lsn_beg, t->lsn_end, t->lba, track_format_name(t->format)); if (r->dryrun) continue; snprintf(file, sizeof(file), "track-%d.raw", i); if ((fd = open(file, O_WRONLY|O_CREAT, 0644)) < 0) ripncode_fatal(r, "failed to open '%s' (%d: %s)", file, errno, strerror(errno)); cdio_paranoia_seek(r->cdpa, t->lsn_beg * CDIO_CD_FRAMESIZE_RAW, SEEK_SET); total = t->lsn_end - t->lsn_beg + 1; for (l = 0; l <= total; l++) { printf("\rreading track sector %d/%d (#%d)...", l, total, t->lsn_beg + l); fflush(stdout); samples = cdio_paranoia_read(r->cdpa, read_status); if (samples == NULL) { msg = cdio_cddap_errors(r->cdda); ripncode_fatal(r, "failed to seek to LSN %d (%s)", t->lsn_beg, msg ? msg : "unknown error"); } n = write(fd, samples, CDIO_CD_FRAMESIZE_RAW); if (n < 0) ripncode_fatal(r, "failed to write sector data (%d: %s)", errno, strerror(errno)); } close(fd); } }