static int fill_buffer(stream_t *s, char *buffer, int max_len)
{
cdda_priv *p = (cdda_priv *)s->priv;
int16_t *buf;
int i;
if (max_len < CDIO_CD_FRAMESIZE_RAW)
return -1;
if ((p->sector < p->start_sector) || (p->sector > p->end_sector)) {
return 0;
}
buf = paranoia_read(p->cdp, cdparanoia_callback);
if (!buf)
return 0;
#if BYTE_ORDER == BIG_ENDIAN
for (i = 0; i < CDIO_CD_FRAMESIZE_RAW / 2; i++)
buf[i] = le2me_16(buf[i]);
#endif
p->sector++;
memcpy(buffer, buf, CDIO_CD_FRAMESIZE_RAW);
for (i = 0; i < p->cd->tracks; i++) {
if (p->cd->disc_toc[i].dwStartSector == p->sector - 1) {
print_track_info(s, i + 1);
break;
}
}
return CDIO_CD_FRAMESIZE_RAW;
}
unsigned ParanoiaStream::ReadAt(void *buffer, uint64_t pos, size_t len,
size_t *pread)
{
/** @todo Isn't thread-safe like the other ReadAt's. Add a mutex. */
if (pos != Tell())
Seek(pos);
if (m_sector == m_last_sector && !m_data)
{
// EOF
*pread = 0;
return 0;
}
if (!m_data)
{
++m_sector;
// TRACE << "Reading sector " << m_sector << "\n";
if (!sm_current_drive)
sm_current_drive = m_drive;
m_data = (const char*)paranoia_read(m_paranoia, &StaticCallback);
if (sm_current_drive == m_drive)
sm_current_drive = NULL;
if (!m_data)
{
TRACE << "Unrecoverable error!\n";
return EIO;
}
// TRACE << "Got sector " << m_sector << "\n";
m_skip = 0;
}
unsigned int lump = 2352 - m_skip;
if (lump > len)
lump = (unsigned int)len;
memcpy(buffer, m_data + m_skip, lump);
m_skip += lump;
if (m_skip == 2352)
{
m_data = NULL;
}
// TRACE << "Returned bytes " << pos << ".." << (pos+lump) << "\n";
*pread = lump;
return 0;
}
static void cdparanoia_callback(long inpos, int function) {
#else
static void cdparanoia_callback(long int inpos, paranoia_cb_mode_t function) {
#endif
}
static int fill_buffer(stream_t* s, char* buffer, int max_len) {
cdda_priv* p = (cdda_priv*)s->priv;
cd_track_t *cd_track;
int16_t * buf;
int i;
buf = paranoia_read(p->cdp,cdparanoia_callback);
if (!buf)
return 0;
#ifdef WORDS_BIGENDIAN
for(i=0;i<CD_FRAMESIZE_RAW/2;i++)
buf[i]=le2me_16(buf[i]);
#endif
p->sector++;
s->pos = p->sector*CD_FRAMESIZE_RAW;
memcpy(buffer,buf,CD_FRAMESIZE_RAW);
if((p->sector < p->start_sector) || (p->sector >= p->end_sector)) {
s->eof = 1;
return 0;
}
for(i=0;i<p->cd->tracks;i++){
if(p->cd->disc_toc[i].dwStartSector==p->sector-1) {
cd_track = cd_info_get_track(p->cd_info, i+1);
//printf("Track %d, sector=%d\n", i, p->sector-1);
if( cd_track!=NULL ) {
mp_msg(MSGT_SEEK, MSGL_INFO, "\n%s\n", cd_track->name);
mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_CDDA_TRACK=%d\n", cd_track->track_nb);
}
break;
}
}
return CD_FRAMESIZE_RAW;
}
static const char *
read_sector(cdda_info_t *info)
{
#if USE_PARANOIA
if (info->paranoia) {
const int16_t *p_readbuf = paranoia_read(info->paranoia, NULL);
if (p_readbuf) {
return (char *)p_readbuf;
}
}
else
#endif
if (!cdio_read_audio_sector(info->cdio, info->buffer, info->current_sector)) {
return info->buffer;
}
return NULL;
}
static GstBuffer *
gst_cd_paranoia_src_read_sector (GstAudioCdSrc * audiocdsrc, gint sector)
{
GstCdParanoiaSrc *src = GST_CD_PARANOIA_SRC (audiocdsrc);
GstBuffer *buf;
gboolean do_serialize;
gint16 *cdda_buf;
#if 0
/* Do we really need to output this? (tpm) */
/* Due to possible autocorrections of start sectors of audio tracks on
* multisession cds, we can maybe not compute the correct discid.
* So issue a warning.
* See cdparanoia/interface/common-interface.c:FixupTOC */
if (src->d && src->d->cd_extra) {
g_message
("DiscID on multisession discs might be broken. Use at own risk.");
}
#endif
if (src->next_sector == -1 || src->next_sector != sector) {
if (paranoia_seek (src->p, sector, SEEK_SET) == -1)
goto seek_failed;
GST_DEBUG_OBJECT (src, "successfully seeked to sector %d", sector);
src->next_sector = sector;
}
do_serialize =
gst_cd_paranoia_src_signal_is_being_watched (src, TRANSPORT_ERROR) ||
gst_cd_paranoia_src_signal_is_being_watched (src, UNCORRECTED_ERROR);
if (do_serialize) {
GST_LOG_OBJECT (src, "Signal handlers connected, serialising access");
g_mutex_lock (&cur_cb_mutex);
GST_LOG_OBJECT (src, "Got lock");
cur_cb_source = src;
cdda_buf = paranoia_read (src->p, gst_cd_paranoia_paranoia_callback);
cur_cb_source = NULL;
GST_LOG_OBJECT (src, "Releasing lock");
g_mutex_unlock (&cur_cb_mutex);
} else {
cdda_buf = paranoia_read (src->p, gst_cd_paranoia_dummy_callback);
}
if (cdda_buf == NULL)
goto read_failed;
buf = gst_buffer_new_and_alloc (CD_FRAMESIZE_RAW);
gst_buffer_fill (buf, 0, cdda_buf, CD_FRAMESIZE_RAW);
/* cdda base class will take care of timestamping etc. */
++src->next_sector;
return buf;
/* ERRORS */
seek_failed:
{
GST_WARNING_OBJECT (src, "seek to sector %d failed!", sector);
GST_ELEMENT_ERROR (src, RESOURCE, SEEK,
(_("Could not seek CD.")),
("paranoia_seek to %d failed: %s", sector, g_strerror (errno)));
return NULL;
}
read_failed:
{
GST_WARNING_OBJECT (src, "read at sector %d failed!", sector);
GST_ELEMENT_ERROR (src, RESOURCE, READ,
(_("Could not read CD.")),
("paranoia_read at %d failed: %s", sector, g_strerror (errno)));
return NULL;
}
}
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);
}
