void AudioCDDemux::readCDText( track_t trackNo )
{
#if LIBCDIO_VERSION_NUM >= 84
if ( cdtext_t *cdtext = cdio_get_cdtext( cdio ) )
{
if ( trackNo == 0 )
{
cdTitle = cdtext_get_const( cdtext, CDTEXT_FIELD_TITLE, 0 );
cdArtist = cdtext_get_const( cdtext, CDTEXT_FIELD_PERFORMER, 0 );
}
else
{
Title = cdtext_get_const( cdtext, CDTEXT_FIELD_TITLE, trackNo );
Artist = cdtext_get_const( cdtext, CDTEXT_FIELD_PERFORMER, trackNo );
Genre = cdtext_get_const( cdtext, CDTEXT_FIELD_GENRE, trackNo );
}
}
#else
if ( cdtext_t *cdtext = cdio_get_cdtext( cdio, trackNo ) )
{
if ( trackNo == 0 )
{
cdTitle = cdtext_get_const( CDTEXT_TITLE, cdtext );
cdArtist = cdtext_get_const( CDTEXT_PERFORMER, cdtext );
}
else
{
Title = cdtext_get_const( CDTEXT_TITLE, cdtext );
Artist = cdtext_get_const( CDTEXT_PERFORMER, cdtext );
Genre = cdtext_get_const( CDTEXT_GENRE, cdtext );
}
}
#endif
}
static bool print_cdtext(stream_t *s, int track)
{
cdda_priv* p = (cdda_priv*)s->priv;
#ifdef OLD_API
cdtext_t *text = cdio_get_cdtext(p->cd->p_cdio, track);
#else
cdtext_t *text = cdio_get_cdtext(p->cd->p_cdio);
#endif
int header = 0;
if (text) {
for (int i = 0; i < sizeof(cdtext_name) / sizeof(cdtext_name[0]); i++) {
const char *name = cdtext_name[i];
#ifdef OLD_API
const char *value = cdtext_get_const(i, text);
#else
const char *value = cdtext_get_const(text, i, track);
#endif
if (name && value) {
if (!header)
MP_INFO(s, "CD-Text (%s):\n", track ? "track" : "CD");
header = 1;
MP_INFO(s, " %s: '%s'\n", name, value);
}
}
return true;
}
return false;
}
GstTagList *
#if LIBCDIO_VERSION_NUM > 83
gst_cdio_get_cdtext (GstObject * src, cdtext_t * t, track_t track)
{
GstTagList *tags = NULL;
#else
gst_cdio_get_cdtext (GstObject * src, CdIo * cdio, track_t track)
{
GstTagList *tags = NULL;
cdtext_t *t;
t = cdio_get_cdtext (cdio, track);
if (t == NULL) {
GST_DEBUG_OBJECT (src, "no CD-TEXT for track %u", track);
return NULL;
}
#endif
gst_cdio_add_cdtext_field (src, t, track, CDTEXT_FIELD_PERFORMER,
GST_TAG_ARTIST, &tags);
gst_cdio_add_cdtext_field (src, t, track, CDTEXT_FIELD_TITLE, GST_TAG_TITLE,
&tags);
return tags;
}
static void
print_cdtext_info(CdIo_t *p_cdio, track_t i_tracks, track_t i_first_track) {
track_t i_last_track = i_first_track+i_tracks;
cdtext_t *p_cdtext = cdio_get_cdtext(p_cdio);
cdtext_lang_t *languages;
int i, j;
if(NULL == p_cdtext) {
printf("No CD-TEXT on Disc.\n");
return;
}
languages = cdtext_list_languages(p_cdtext);
for(i=0; i<8; i++)
if ( CDTEXT_LANGUAGE_UNKNOWN != languages[i]
&& cdtext_select_language(p_cdtext, languages[i]))
{
printf("\nLanguage %d '%s':\n", i, cdtext_lang2str(languages[i]));
print_cdtext_track_info(p_cdtext, 0, "CD-TEXT for Disc:");
for ( j = i_first_track ; j < i_last_track; j++ ) {
char msg[50];
sprintf(msg, "CD-TEXT for Track %2d:", j);
print_cdtext_track_info(p_cdtext, j, msg);
}
}
}
static int
read_disc_cdtext (CdIo_t *cdio, DB_playItem_t **items, const track_t tracks)
{
#if CDIO_API_VERSION >= 6
cdtext_t *cdtext = cdio_get_cdtext(cdio);
#else
cdtext_t *cdtext = cdio_get_cdtext(cdio, 0);
#endif
if (!cdtext) {
return 0;
}
for (track_t i = 0; i < tracks; i++) {
read_track_cdtext(cdio, deadbeef->pl_find_meta_int(items[i], "track", 0), items[i]);
}
return 1;
}
static void
get_cdtext_track_info(track_t i_track)
{
cdtext_t *p_cdtext = cdio_get_cdtext(p_cdio);
if (NULL != p_cdtext) {
add_cdtext_track_info("%s", title, CDTEXT_FIELD_TITLE);
add_cdtext_track_info("%s", artist, CDTEXT_FIELD_PERFORMER);
}
}
static void
get_cdtext_disc_info(CdIo_t *p_cdio)
{
cdtext_t *p_cdtext = cdio_get_cdtext(p_cdio);
if (p_cdtext) {
add_cdtext_disc_info("%s", title, CDTEXT_FIELD_TITLE);
add_cdtext_disc_info("%s", artist, CDTEXT_FIELD_PERFORMER);
add_cdtext_disc_info("%s", genre, CDTEXT_FIELD_GENRE);
}
}
static int
read_disc_cdtext (struct cddb_thread_params *params)
{
DB_playItem_t **items = params->items;
cdtext_t *cdtext = cdio_get_cdtext (params->cdio, 0);
if (!cdtext)
return 0;
track_t first_track = cdio_get_first_track_num (params->cdio);
track_t tracks = cdio_get_num_tracks (params->cdio);
track_t i;
for (i = 0; i < tracks; i++)
read_track_cdtext (params->cdio, i + first_track, params->items[i]);
return 1;
}
static void
print_cdtext_track_info(CdIo_t *p_cdio, track_t i_track, const char *psz_msg) {
const cdtext_t *cdtext = cdio_get_cdtext(p_cdio, 0);
if (NULL != cdtext) {
cdtext_field_t i;
printf("%s\n", psz_msg);
for (i=0; i < MAX_CDTEXT_FIELDS; i++) {
if (cdtext->field[i]) {
printf("\t%s: %s\n", cdtext_field2str(i), cdtext->field[i]);
}
}
}
}
void CddaImpl::read_toc()
{
_cdtext = cdio_get_cdtext(_cdio);
track_t tracks = cdda_tracks(_cdrom);
for (int i = 1; i <= tracks; i++)
{
if (not cdda_track_audiop(_cdrom, i))
continue;
CddaTrackImpl* cd_track = new CddaTrackImpl(this, i);
_tracks.push_back(cd_track);
_audio_length += cd_track->offset();
}
}
gst_cdio_add_cdtext_album_tags (GstObject * src, CdIo * cdio, GstTagList * tags)
{
cdtext_t *t;
t = cdio_get_cdtext (cdio, 0);
if (t == NULL) {
GST_DEBUG_OBJECT (src, "no CD-TEXT for album");
return;
}
#endif
gst_cdio_add_cdtext_field (src, t, 0, CDTEXT_FIELD_PERFORMER,
GST_TAG_ALBUM_ARTIST, &tags);
gst_cdio_add_cdtext_field (src, t, 0, CDTEXT_FIELD_TITLE, GST_TAG_ALBUM,
&tags);
gst_cdio_add_cdtext_field (src, t, 0, CDTEXT_FIELD_GENRE, GST_TAG_GENRE,
&tags);
GST_DEBUG ("CD-TEXT album tags: %" GST_PTR_FORMAT, tags);
}
static void
read_track_cdtext (CdIo_t *cdio, int track_nr, DB_playItem_t *item)
{
cdtext_t *cdtext = cdio_get_cdtext (cdio, 0);
if (!cdtext)
{
trace ("No cdtext\n");
return;
}
const char *artist = NULL;
const char *album = NULL;
int field_type;
for (field_type = 0; field_type < MAX_CDTEXT_FIELDS; field_type++)
{
const char *text = cdtext_get_const (field_type, cdtext);
const char *field = NULL;
if (text)
{
switch (field_type)
{
case CDTEXT_TITLE: album = text; break;
case CDTEXT_PERFORMER: artist = text; break;
}
}
}
trace ("artist: %s; album: %s\n", artist, album);
if (artist) {
deadbeef->pl_replace_meta (item, "artist", artist);
}
if (album) {
deadbeef->pl_replace_meta (item, "album", album);
}
cdtext = cdio_get_cdtext (cdio, track_nr);
if (!cdtext)
return;
for (field_type = 0; field_type < MAX_CDTEXT_FIELDS; field_type++)
{
const char *text = cdtext_get_const (field_type, cdtext);
const char *field = NULL;
if (!text)
continue;
switch (field_type)
{
case CDTEXT_TITLE: field = "title"; break;
case CDTEXT_PERFORMER: field = "artist"; break;
case CDTEXT_COMPOSER: field = "composer"; break;
case CDTEXT_GENRE: field = "genre"; break;
case CDTEXT_SONGWRITER: field = "songwriter"; break;
case CDTEXT_MESSAGE: field = "comment"; break;
default: field = NULL;
}
if (field && text)
{
trace ("%s: %s\n", field, text);
deadbeef->pl_replace_meta (item, field, text);
}
}
}
static void
read_track_cdtext (CdIo_t *cdio, int track_nr, DB_playItem_t *item)
{
#if CDIO_API_VERSION >= 6
cdtext_t *cdtext = cdio_get_cdtext (cdio);
#else
cdtext_t *cdtext = cdio_get_cdtext (cdio, 0);
#endif
if (!cdtext) {
trace ("No cdtext\n");
return;
}
const char *artist = NULL;
const char *album = NULL;
int field_type;
for (field_type = 0; field_type < MAX_CDTEXT_FIELDS; field_type++) {
#if CDIO_API_VERSION >= 6
const char *text = cdtext_get_const (cdtext, field_type, track_nr);
#else
const char *text = cdtext_get_const (field_type, cdtext);
#endif
if (text) {
switch (field_type) {
#if CDIO_API_VERSION >= 6
case CDTEXT_FIELD_TITLE: album = text; break;
case CDTEXT_FIELD_PERFORMER: artist = text; break;
#else
case CDTEXT_TITLE: album = text; break;
case CDTEXT_PERFORMER: artist = text; break;
#endif
}
}
}
trace ("artist: %s; album: %s\n", artist, album);
replace_meta(item, "artist", artist);
replace_meta(item, "album", album);
#if CDIO_API_VERSION >= 6
cdtext = cdio_get_cdtext (cdio);
#else
cdtext = cdio_get_cdtext (cdio, track_nr);
#endif
if (!cdtext) {
return;
}
for (field_type = 0; field_type < MAX_CDTEXT_FIELDS; field_type++) {
#if CDIO_API_VERSION >= 6
const char *text = cdtext_get_const (cdtext, field_type, track_nr);
#else
const char *text = cdtext_get_const (field_type, cdtext);
#endif
if (!text) {
continue;
}
const char *field = NULL;
switch (field_type) {
#if CDIO_API_VERSION >= 6
case CDTEXT_FIELD_TITLE: field = "title"; break;
case CDTEXT_FIELD_PERFORMER: field = "artist"; break;
case CDTEXT_FIELD_COMPOSER: field = "composer"; break;
case CDTEXT_FIELD_GENRE: field = "genre"; break;
case CDTEXT_FIELD_SONGWRITER: field = "songwriter"; break;
case CDTEXT_FIELD_MESSAGE: field = "comment"; break;
#else
case CDTEXT_TITLE: field = "title"; break;
case CDTEXT_PERFORMER: field = "artist"; break;
case CDTEXT_COMPOSER: field = "composer"; break;
case CDTEXT_GENRE: field = "genre"; break;
case CDTEXT_SONGWRITER: field = "songwriter"; break;
case CDTEXT_MESSAGE: field = "comment"; break;
#endif
default: field = NULL;
}
if (field) {
trace("%s: %s\n", field, text);
replace_meta(item, field, text);
}
}
}
//virtual
Metadata *CdDecoder::getMetadata()
{
QString artist, album, compilation_artist, title, genre;
int year = 0;
unsigned long length = 0;
track_t tracknum = 0;
if (-1 == m_settracknum)
tracknum = getFilename().toUInt();
else
{
tracknum = m_settracknum;
setFilename(QString("%1" CDEXT).arg(tracknum));
}
QMutexLocker lock(&getCdioMutex());
StCdioDevice cdio(m_devicename);
if (!cdio)
return NULL;
const track_t lastTrack = cdio_get_last_track_num(cdio);
if (CDIO_INVALID_TRACK == lastTrack)
return NULL;
if (TRACK_FORMAT_AUDIO != cdio_get_track_format(cdio, tracknum))
return NULL;
// Assume disc changed if max LSN different
bool isDiscChanged = false;
static lsn_t s_totalSectors;
lsn_t totalSectors = cdio_get_track_lsn(cdio, CDIO_CDROM_LEADOUT_TRACK);
if (s_totalSectors != totalSectors)
{
s_totalSectors = totalSectors;
isDiscChanged = true;
}
// NB cdio_get_track_last_lsn is unreliable for the last audio track
// of discs with data tracks beyond
lsn_t end = cdio_get_track_last_lsn(cdio, tracknum);
if (isDiscChanged)
{
const track_t audioTracks = getNumCDAudioTracks();
s_lastAudioLsn = cdio_get_track_last_lsn(cdio, audioTracks);
if (audioTracks < lastTrack)
{
cdrom_drive_t *dev = cdio_cddap_identify_cdio(cdio, 0, NULL);
if (NULL != dev)
{
if (DRIVER_OP_SUCCESS == cdio_cddap_open(dev))
{
// NB this can be S L O W but is reliable
lsn_t end2 = cdio_cddap_track_lastsector(dev,
getNumCDAudioTracks());
if (CDIO_INVALID_LSN != end2)
s_lastAudioLsn = end2;
}
cdio_cddap_close_no_free_cdio(dev);
}
}
}
if (s_lastAudioLsn && s_lastAudioLsn < end)
end = s_lastAudioLsn;
const lsn_t start = cdio_get_track_lsn(cdio, tracknum);
if (CDIO_INVALID_LSN != start && CDIO_INVALID_LSN != end)
{
length = ((end - start + 1) * 1000 + CDIO_CD_FRAMES_PER_SEC/2) /
CDIO_CD_FRAMES_PER_SEC;
}
bool isCompilation = false;
#define CDTEXT 0 // Disabled - cd-text access on discs without it is S L O W
#if CDTEXT
static int s_iCdtext;
if (isDiscChanged)
s_iCdtext = -1;
if (s_iCdtext)
{
// cdio_get_cdtext can't take >5 seconds on some CD's without cdtext
if (s_iCdtext < 0)
LOG(VB_MEDIA, LOG_INFO,
QString("Getting cdtext for track %1...").arg(tracknum));
cdtext_t * cdtext = cdio_get_cdtext(m_cdio, tracknum);
if (NULL != cdtext)
{
genre = cdtext_get_const(CDTEXT_GENRE, cdtext);
artist = cdtext_get_const(CDTEXT_PERFORMER, cdtext);
title = cdtext_get_const(CDTEXT_TITLE, cdtext);
const char* isrc = cdtext_get_const(CDTEXT_ISRC, cdtext);
/* ISRC codes are 12 characters long, in the form CCXXXYYNNNNN
* CC = country code
* XXX = registrant e.g. BMG
* CC = year withou century
* NNNNN = unique ID
*/
if (isrc && strlen(isrc) >= 7)
{
year = (isrc[5] - '0') * 10 + (isrc[6] - '0');
year += (year <= 30) ? 2000 : 1900;
}
cdtext_destroy(cdtext);
if (!title.isNull())
{
if (s_iCdtext < 0)
LOG(VB_MEDIA, LOG_INFO, "Found cdtext track title");
s_iCdtext = 1;
// Get disc info
cdtext = cdio_get_cdtext(cdio, 0);
if (NULL != cdtext)
{
compilation_artist = cdtext_get_const(
CDTEXT_PERFORMER, cdtext);
if (!compilation_artist.isEmpty() &&
artist != compilation_artist)
isCompilation = true;
album = cdtext_get_const(CDTEXT_TITLE, cdtext);
if (genre.isNull())
genre = cdtext_get_const(CDTEXT_GENRE, cdtext);
cdtext_destroy(cdtext);
}
}
else
{
if (s_iCdtext < 0)
LOG(VB_MEDIA, LOG_INFO, "No cdtext title for track");
s_iCdtext = 0;
}
}
else
{
if (s_iCdtext < 0)
LOG(VB_MEDIA, LOG_INFO, "No cdtext");
s_iCdtext = 0;
}
}
if (title.isEmpty() || artist.isEmpty() || album.isEmpty())
#endif // CDTEXT
{
// CDDB lookup
Cddb::Toc toc;
Cddb::Matches r;
if (Cddb::Query(r, GetToc(cdio, toc)))
{
Cddb::Matches::match_t::const_iterator select = r.matches.begin();
if (r.matches.size() > 1)
{
// TODO prompt user to select one
// In the meantime, select the first non-generic genre
for (Cddb::Matches::match_t::const_iterator it = select;
it != r.matches.end(); ++it)
{
QString g = it->genre.toLower();
if (g != "misc" && g != "data")
{
select = it;
break;
}
}
}
Cddb::Album info;
if (Cddb::Read(info, select->genre, select->discID))
{
isCompilation = info.isCompilation;
if (info.genre.toLower() != "misc")
genre = info.genre;
album = info.title;
compilation_artist = info.artist;
year = info.year;
if (info.tracks.size() >= tracknum)
{
const Cddb::Track& track = info.tracks[tracknum - 1];
title = track.title;
artist = track.artist;
}
// Create a temporary local alias for future lookups
if (r.discID != info.discID)
Cddb::Alias(info, r.discID);
}
}
}
if (compilation_artist.toLower().left(7) == "various")
compilation_artist = QObject::tr("Various Artists");
if (artist.isEmpty())
{
artist = compilation_artist;
compilation_artist.clear();
}
if (title.isEmpty())
title = QObject::tr("Track %1").arg(tracknum);
Metadata *m = new Metadata(getFilename(), artist, compilation_artist,
album, title, genre, year, tracknum, length);
if (m)
m->setCompilation(isCompilation);
return m;
}
/* Returns 0 on success, 1 on failure */
int
update_track_data_from_cdtext(cdda_drive_t * drive, GtkTreeIter * iter_drive) {
CdIo_t * cdio;
cdtext_t * cdtext;
GtkTreeIter iter;
int i;
int ret = 0;
cdio = cdio_open(drive->device_path, DRIVER_UNKNOWN);
cdtext = cdio_get_cdtext(cdio, 0);
if (cdtext == NULL) {
ret = 1;
} else {
char tmp[MAXLEN];
tmp[0] = '\0';
if (cdtext->field[CDTEXT_PERFORMER] != NULL && *(cdtext->field[CDTEXT_PERFORMER]) != '\0') {
strncat(tmp, cdtext->field[CDTEXT_PERFORMER], MAXLEN-1);
strncpy(drive->disc.artist_name, cdtext->field[CDTEXT_PERFORMER], MAXLEN-1);
} else {
ret = 1;
}
strncat(tmp, ": ", MAXLEN - strlen(tmp) - 1);
if (cdtext->field[CDTEXT_TITLE] != NULL && *(cdtext->field[CDTEXT_TITLE]) != '\0') {
strncat(tmp, cdtext->field[CDTEXT_TITLE], MAXLEN - strlen(tmp) - 1);
strncpy(drive->disc.record_name, cdtext->field[CDTEXT_TITLE], MAXLEN-1);
} else {
ret = 1;
}
if (ret == 0) {
gtk_tree_store_set(music_store, iter_drive, MS_COL_NAME, tmp, -1);
}
}
i = 0;
while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store), &iter, iter_drive, i++)) {
cdtext = cdio_get_cdtext(cdio, i);
if (cdtext == NULL) {
ret = 1;
continue;
}
if (cdtext->field[CDTEXT_TITLE] != NULL && *(cdtext->field[CDTEXT_TITLE]) != '\0') {
gtk_tree_store_set(music_store, &iter, MS_COL_NAME, cdtext->field[CDTEXT_TITLE], -1);
} else {
ret = 1;
}
}
cdio_destroy(cdio);
return ret;
}
/* mutex must be locked */
static void scan_cd (void)
{
AUDDBG ("Scanning CD drive.\n");
g_return_if_fail (pcdrom_drive != NULL);
g_return_if_fail (trackinfo == NULL);
gint trackno;
/* general track initialization */
/* skip endianness detection (because it only affects cdda_read, and we use
* cdio_read_audio_sectors instead) */
pcdrom_drive->bigendianp = 0;
/* finish initialization of drive/disc (performs disc TOC sanitization) */
if (cdda_open (pcdrom_drive) != 0)
{
cdaudio_error ("Failed to finish initializing opened CD drive.");
goto ERR;
}
if (cdda_speed_set (pcdrom_drive, cdng_cfg.disc_speed) != DRIVER_OP_SUCCESS)
warn ("Cannot set drive speed.\n");
firsttrackno = cdio_get_first_track_num (pcdrom_drive->p_cdio);
lasttrackno = cdio_get_last_track_num (pcdrom_drive->p_cdio);
if (firsttrackno == CDIO_INVALID_TRACK || lasttrackno == CDIO_INVALID_TRACK)
{
cdaudio_error ("Failed to retrieve first/last track number.");
goto ERR;
}
AUDDBG ("first track is %d and last track is %d\n", firsttrackno,
lasttrackno);
trackinfo = (trackinfo_t *) g_new (trackinfo_t, (lasttrackno + 1));
cdaudio_set_fullinfo (&trackinfo[0],
cdda_track_firstsector (pcdrom_drive, 0),
cdda_track_lastsector (pcdrom_drive, lasttrackno),
"", "", "");
n_audio_tracks = 0;
for (trackno = firsttrackno; trackno <= lasttrackno; trackno++)
{
cdaudio_set_fullinfo (&trackinfo[trackno],
cdda_track_firstsector (pcdrom_drive, trackno),
cdda_track_lastsector (pcdrom_drive, trackno),
"", "", "");
if (trackinfo[trackno].startlsn == CDIO_INVALID_LSN
|| trackinfo[trackno].endlsn == CDIO_INVALID_LSN)
{
cdaudio_error ("Cannot read start/end LSN for track %d.", trackno);
goto ERR;
}
/* count how many tracks are audio tracks */
if (cdda_track_audiop (pcdrom_drive, trackno))
n_audio_tracks++;
}
/* get trackinfo[0] cdtext information (the disc) */
if (cdng_cfg.use_cdtext)
{
AUDDBG ("getting cd-text information for disc\n");
cdtext_t *pcdtext = cdio_get_cdtext (pcdrom_drive->p_cdio, 0);
if (pcdtext == NULL || pcdtext->field[CDTEXT_TITLE] == NULL)
{
AUDDBG ("no cd-text available for disc\n");
}
else
{
cdaudio_set_strinfo (&trackinfo[0],
pcdtext->field[CDTEXT_PERFORMER] ? pcdtext->
field[CDTEXT_PERFORMER] : "",
pcdtext->field[CDTEXT_TITLE] ? pcdtext->
field[CDTEXT_TITLE] : "",
pcdtext->field[CDTEXT_GENRE] ? pcdtext->
field[CDTEXT_GENRE] : "");
}
}
/* get track information from cdtext */
gboolean cdtext_was_available = FALSE;
for (trackno = firsttrackno; trackno <= lasttrackno; trackno++)
{
cdtext_t *pcdtext = NULL;
if (cdng_cfg.use_cdtext)
{
AUDDBG ("getting cd-text information for track %d\n", trackno);
pcdtext = cdio_get_cdtext (pcdrom_drive->p_cdio, trackno);
if (pcdtext == NULL || pcdtext->field[CDTEXT_PERFORMER] == NULL)
{
AUDDBG ("no cd-text available for track %d\n", trackno);
pcdtext = NULL;
}
}
if (pcdtext != NULL)
{
cdaudio_set_strinfo (&trackinfo[trackno],
pcdtext->field[CDTEXT_PERFORMER] ? pcdtext->
field[CDTEXT_PERFORMER] : "",
pcdtext->field[CDTEXT_TITLE] ? pcdtext->
field[CDTEXT_TITLE] : "",
pcdtext->field[CDTEXT_GENRE] ? pcdtext->
field[CDTEXT_GENRE] : "");
cdtext_was_available = TRUE;
}
else
{
cdaudio_set_strinfo (&trackinfo[trackno], "", "", "");
snprintf (trackinfo[trackno].name, DEF_STRING_LEN,
"Track %d", trackno);
}
}
if (!cdtext_was_available)
{
/* initialize de cddb subsystem */
cddb_conn_t *pcddb_conn = NULL;
cddb_disc_t *pcddb_disc = NULL;
cddb_track_t *pcddb_track = NULL;
lba_t lba; /* Logical Block Address */
if (cdng_cfg.use_cddb)
{
pcddb_conn = cddb_new ();
if (pcddb_conn == NULL)
cdaudio_error ("Failed to create the cddb connection.");
else
{
AUDDBG ("getting CDDB info\n");
cddb_cache_enable (pcddb_conn);
// cddb_cache_set_dir(pcddb_conn, "~/.cddbslave");
if (cdng_cfg.use_proxy)
{
cddb_http_proxy_enable (pcddb_conn);
cddb_set_http_proxy_server_name (pcddb_conn,
cdng_cfg.proxy_host);
cddb_set_http_proxy_server_port (pcddb_conn,
cdng_cfg.proxy_port);
cddb_set_http_proxy_username (pcddb_conn,
cdng_cfg.proxy_username);
cddb_set_http_proxy_password (pcddb_conn,
cdng_cfg.proxy_password);
cddb_set_server_name (pcddb_conn, cdng_cfg.cddb_server);
cddb_set_server_port (pcddb_conn, cdng_cfg.cddb_port);
}
else if (cdng_cfg.cddb_http)
{
cddb_http_enable (pcddb_conn);
cddb_set_server_name (pcddb_conn, cdng_cfg.cddb_server);
cddb_set_server_port (pcddb_conn, cdng_cfg.cddb_port);
cddb_set_http_path_query (pcddb_conn, cdng_cfg.cddb_path);
}
else
{
cddb_set_server_name (pcddb_conn, cdng_cfg.cddb_server);
cddb_set_server_port (pcddb_conn, cdng_cfg.cddb_port);
}
pcddb_disc = cddb_disc_new ();
lba = cdio_get_track_lba (pcdrom_drive->p_cdio,
CDIO_CDROM_LEADOUT_TRACK);
cddb_disc_set_length (pcddb_disc, FRAMES_TO_SECONDS (lba));
for (trackno = firsttrackno; trackno <= lasttrackno; trackno++)
{
pcddb_track = cddb_track_new ();
cddb_track_set_frame_offset (pcddb_track,
cdio_get_track_lba (
pcdrom_drive->p_cdio,
trackno));
cddb_disc_add_track (pcddb_disc, pcddb_track);
}
cddb_disc_calc_discid (pcddb_disc);
#if DEBUG
guint discid = cddb_disc_get_discid (pcddb_disc);
AUDDBG ("CDDB disc id = %x\n", discid);
#endif
gint matches;
if ((matches = cddb_query (pcddb_conn, pcddb_disc)) == -1)
{
if (cddb_errno (pcddb_conn) == CDDB_ERR_OK)
cdaudio_error ("Failed to query the CDDB server");
else
cdaudio_error ("Failed to query the CDDB server: %s",
cddb_error_str (cddb_errno
(pcddb_conn)));
cddb_disc_destroy (pcddb_disc);
pcddb_disc = NULL;
}
else
{
if (matches == 0)
{
AUDDBG ("no cddb info available for this disc\n");
cddb_disc_destroy (pcddb_disc);
pcddb_disc = NULL;
}
else
{
AUDDBG ("CDDB disc category = \"%s\"\n",
cddb_disc_get_category_str (pcddb_disc));
cddb_read (pcddb_conn, pcddb_disc);
if (cddb_errno (pcddb_conn) != CDDB_ERR_OK)
{
cdaudio_error ("failed to read the cddb info: %s",
cddb_error_str (cddb_errno
(pcddb_conn)));
cddb_disc_destroy (pcddb_disc);
pcddb_disc = NULL;
}
else
{
cdaudio_set_strinfo (&trackinfo[0],
cddb_disc_get_artist
(pcddb_disc),
cddb_disc_get_title
(pcddb_disc),
cddb_disc_get_genre
(pcddb_disc));
gint trackno;
for (trackno = firsttrackno; trackno <= lasttrackno;
trackno++)
{
cddb_track_t *pcddb_track =
cddb_disc_get_track (pcddb_disc,
trackno - 1);
cdaudio_set_strinfo (&trackinfo[trackno],
cddb_track_get_artist
(pcddb_track),
cddb_track_get_title
(pcddb_track),
cddb_disc_get_genre
(pcddb_disc));
}
}
}
}
}
}
if (pcddb_disc != NULL)
cddb_disc_destroy (pcddb_disc);
if (pcddb_conn != NULL)
cddb_destroy (pcddb_conn);
}
return;
ERR:
g_free (trackinfo);
trackinfo = NULL;
}
/*!
Get CD-Text information for a CdIo_t object.
@return the CD-Text object or NULL if obj is NULL
or CD-Text information does not exist.
*/
cdtext_t *getCdtext ()
{
return cdio_get_cdtext (p_cdio, i_track);
}
