static int read_packet(AVFormatContext *ctx, AVPacket *pkt)
{
CDIOContext *s = ctx->priv_data;
int ret;
uint16_t *buf;
char *err = NULL;
if (ctx->streams[0]->cur_dts > s->last_sector)
return AVERROR_EOF;
buf = cdio_paranoia_read(s->paranoia, NULL);
if (!buf)
return AVERROR_EOF;
if (err = cdio_cddap_errors(s->drive)) {
av_log(ctx, AV_LOG_ERROR, "%s\n", err);
free(err);
err = NULL;
}
if (err = cdio_cddap_messages(s->drive)) {
av_log(ctx, AV_LOG_VERBOSE, "%s\n", err);
free(err);
err = NULL;
}
if ((ret = av_new_packet(pkt, CDIO_CD_FRAMESIZE_RAW)) < 0)
return ret;
memcpy(pkt->data, buf, CDIO_CD_FRAMESIZE_RAW);
return 0;
}
/*!
*/
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;
}
int RipAttempt() {
for ( i_cursor = i_first_lsn; i_cursor <= i_last_lsn; ) {
for ( int i = 0; i < NUM_TRIES; i++) {
paranoia_seek(p, i_cursor, SEEK_SET);
for ( int j = 0; j < NUM_SECTORS && j <= (i_last_lsn - i_cursor); j++ ) {
/* read a sector */
int16_t *p_readbuf = cdio_paranoia_read(p, NULL);
int16_t *buf_pointer;
psz_err = cdio_cddap_errors(d);
psz_mes = cdio_cddap_messages(d);
if (psz_mes || psz_err)
printf("%s%s\n", psz_mes ? psz_mes: "", psz_err ? psz_err: "");
if (psz_err) free(psz_err);
if (psz_mes) free(psz_mes);
if( !p_readbuf ) {
printf("paranoia read error. Stopping.\n");
break;
} else {
/* Transport data to actual buffer */
if ( i == 0 ) {
for ( buf_pointer = p_readbuf, counter = (CDIO_CD_FRAMESIZE_RAW/2)*j; buf_pointer != NULL && counter < (CDIO_CD_FRAMESIZE_RAW/2)*(j+1); buf_pointer++, counter++ ) {
readbuf[counter] = *buf_pointer;
}
} else {
for ( buf_pointer = p_readbuf, counter = (CDIO_CD_FRAMESIZE_RAW/2)*j; buf_pointer != NULL && counter < (CDIO_CD_FRAMESIZE_RAW/2)*(j+1); buf_pointer++, counter++ ) {
readbuf2[counter] = *buf_pointer;
}
}
}
num_samples = counter;
}
}
failed = false;
for (int i = 0; i < num_samples ; i++) {
if (readbuf[i] != readbuf2[i]) {
failed = true;
}
}
if (!failed) {
i_cursor += NUM_SECTORS;
written_samples = WriteToFile();
if (written_samples != num_samples) return 1;
}
}
return 0;
}
int
main(int argc, const char *argv[])
{
cdrom_drive_t *d = NULL; /* Place to store handle given by cd-parapnioa. */
driver_id_t driver_id;
char **ppsz_cd_drives; /* List of all drives with a loaded CDDA in it. */
int i_rc=0;
/* See if we can find a device with a loaded CD-DA in it. If successful
drive_id will be set. */
ppsz_cd_drives = cdio_get_devices_with_cap_ret(NULL, CDIO_FS_AUDIO, false,
&driver_id);
if (ppsz_cd_drives && *ppsz_cd_drives) {
/* Found such a CD-ROM with a CD-DA loaded. Use the first drive in
the list. */
d=cdda_identify(*ppsz_cd_drives, 1, NULL);
} else {
printf("Unable find or access a CD-ROM drive with an audio CD in it.\n");
exit(SKIP_TEST_RC);
}
/** We had a bug in is_device when driver_id == DRIVER_UNKNOWN or
DRIVER_DEVICE. Let's make sure we've fixed that problem. **/
if (!cdio_is_device(*ppsz_cd_drives, DRIVER_UNKNOWN) ||
!cdio_is_device(*ppsz_cd_drives, DRIVER_DEVICE))
exit(99);
/* Don't need a list of CD's with CD-DA's any more. */
cdio_free_device_list(ppsz_cd_drives);
/* We'll set for verbose paranoia messages. */
cdda_verbose_set(d, CDDA_MESSAGE_PRINTIT, CDDA_MESSAGE_PRINTIT);
if ( 0 != cdio_cddap_open(d) ) {
printf("Unable to open disc.\n");
exit(SKIP_TEST_RC);
}
/* Okay now set up to read up to the first 300 frames of the first
audio track of the Audio CD. */
{
cdrom_paranoia_t *p = paranoia_init(d);
lsn_t i_first_lsn = cdda_disc_firstsector(d);
if ( -1 == i_first_lsn ) {
printf("Trouble getting starting LSN\n");
} else {
lsn_t i_lsn; /* Current LSN to read */
lsn_t i_last_lsn = cdda_disc_lastsector(d);
unsigned int i_sectors = i_last_lsn - i_first_lsn + 1;
unsigned int j;
unsigned int i_good = 0;
unsigned int i_bad = 0;
/* Set reading mode for full paranoia, but allow skipping sectors. */
paranoia_modeset(p, PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP);
for ( j=0; j<10; j++ ) {
/* Pick a place to start reading. */
i_lsn = i_first_lsn + (rand() % i_sectors);
paranoia_seek(p, i_lsn, SEEK_SET);
printf("Testing %d sectors starting at %ld\n",
MAX_SECTORS, (long int) i_lsn);
for ( i = 0;
i < MAX_SECTORS && i_lsn <= i_last_lsn;
i++, i_lsn++ ) {
/* read a sector */
int16_t *p_readbuf = paranoia_read(p, callback);
char *psz_err=cdio_cddap_errors(d);
char *psz_mes=cdio_cddap_messages(d);
memcpy(audio_buf[i], p_readbuf, CDIO_CD_FRAMESIZE_RAW);
if (psz_mes || psz_err)
printf("%s%s\n", psz_mes ? psz_mes: "", psz_err ? psz_err: "");
if (psz_err) free(psz_err);
if (psz_mes) free(psz_mes);
if( !p_readbuf ) {
printf("paranoia read error. Stopping.\n");
goto out;
}
}
/* Compare with the sectors from paranoia. */
i_lsn -= MAX_SECTORS;
for ( i = 0; i < MAX_SECTORS; i++, i_lsn++ ) {
uint8_t readbuf[CDIO_CD_FRAMESIZE_RAW] = {0,};
if ( PARANOIA_CB_READ == audio_status[i] ||
PARANOIA_CB_VERIFY == audio_status[i] ) {
/* We read the block via paranoia without an error. */
if ( 0 == cdio_read_audio_sector(d->p_cdio, readbuf, i_lsn) ) {
if ( BIGENDIAN != d->bigendianp ) {
/* We will compare in the slow, pedantic way*/
int j;
for (j=0; j < CDIO_CD_FRAMESIZE_RAW ; j +=2) {
if (audio_buf[i][j] != readbuf[j+1] &&
audio_buf[i][j+1] != readbuf[j] ) {
printf("LSN %ld doesn't match\n", (long int) i_lsn);
i_bad++;
} else {
i_good++;
}
}
} else {
if ( 0 != memcmp(audio_buf[i], readbuf,
CDIO_CD_FRAMESIZE_RAW) ) {
printf("LSN %ld doesn't match\n", (long int) i_lsn);
i_bad++;
} else {
i_good++;
}
}
}
} else {
printf("Skipping LSN %ld because of status: %s\n",
(long int) i_lsn, paranoia_cb_mode2str[audio_status[i]]);
}
}
}
printf("%u sectors compared okay %u sectors were different\n",
i_good, i_bad);
if (i_bad > i_good) i_rc = 1;
}
out: paranoia_free(p);
}
cdio_cddap_close(d);
exit(i_rc);
}
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);
}
}
