static int
resolve_disc (cddb_disc_t* disc, char *disc_list)
{
trace("cda: resolve_disc\n");
cddb_conn_t *conn = new_cddb_connection();
if (!conn) {
return 0;
}
cddb_disc_t *temp_disc = cddb_disc_clone(disc);
cddb_disc_t *query_disc = disc;
cddb_cache_disable(conn);
const int matches = cddb_query(conn, query_disc);
cddb_cache_enable(conn);
size_t discs_read = 0;
disc_list[0] = '\0';
for (int i = 0; i < matches; i++) {
if (cddb_read(conn, query_disc) && discs_read < MAX_CDDB_DISCS) {
discs_read++;
char temp_string[CDDB_CATEGORY_SIZE + CDDB_DISCID_SIZE + 1];
sprintf(temp_string, ",%s/%08x", cddb_disc_get_category_str(query_disc), cddb_disc_get_discid(query_disc));
strcat(disc_list, temp_string);
query_disc = temp_disc;
}
cddb_query_next(conn, query_disc);
}
cddb_disc_destroy(temp_disc);
cddb_destroy(conn);
return discs_read;
}
static DB_playItem_t *
insert_disc (ddb_playlist_t *plt, DB_playItem_t *after, const char *path, const track_t single_track, CdIo_t* cdio)
{
struct cddb_thread_params *p = calloc(1, sizeof(struct cddb_thread_params));
if (!p) {
return NULL;
}
p->disc = create_disc(cdio);
if (!p->disc) {
cleanup_thread_params(p);
return NULL;
}
const track_t tracks = single_track ? 1 : cddb_disc_get_track_count(p->disc);
p->items = calloc(tracks+1, sizeof(*p->items));
if (!p->items) {
cleanup_thread_params(p);
return NULL;
}
const unsigned long discid = cddb_disc_get_discid(p->disc);
DB_playItem_t *inserted = NULL;
const track_t first_track = single_track ? single_track : cdio_get_first_track_num(cdio);
track_t item_count = 0;
for (track_t i = 0; i < tracks; i++) {
if (cdio_get_track_format(cdio, first_track+i) == TRACK_FORMAT_AUDIO) {
trace("inserting track %d from %s\n", first_track+i, path);
inserted = insert_track(plt, after, path, first_track+i, cdio, discid);
p->items[item_count++] = inserted;
after = inserted;
}
}
intptr_t tid = 0;
if (item_count) {
const int got_cdtext = read_disc_cdtext(cdio, p->items, tracks);
const int prefer_cdtext = deadbeef->conf_get_int("cdda.prefer_cdtext", DEFAULT_PREFER_CDTEXT);
const int enable_cddb = deadbeef->conf_get_int("cdda.freedb.enable", DEFAULT_USE_CDDB);
if (!(got_cdtext && prefer_cdtext) && enable_cddb) {
trace("cdda: querying freedb...\n");
tid = deadbeef->thread_start(cddb_thread, p);
if (tid) {
deadbeef->thread_detach(tid);
}
}
}
if (!tid) {
cleanup_thread_params(p);
}
return inserted;
}
static int
cda_init (DB_fileinfo_t *_info, DB_playItem_t *it) {
cdda_info_t *info = (cdda_info_t *)_info;
trace ("cdda: init %s\n", deadbeef->pl_find_meta (it, ":URI"));
size_t l = strlen (deadbeef->pl_find_meta (it, ":URI"));
char location[l+1];
memcpy (location, deadbeef->pl_find_meta (it, ":URI"), l+1);
char *nr = strchr (location, '#');
if (nr) {
*nr = 0; nr++;
}
else {
trace ("cdda: bad name: %s\n", deadbeef->pl_find_meta (it, ":URI"));
return -1;
}
int track_nr = atoi (nr);
char *fname = (*location) ? location : NULL; //NULL if empty string; means pysical CD drive
info->cdio = cdio_open (fname, DRIVER_UNKNOWN);
if (!info->cdio)
{
trace ("cdda: Could not open CD\n");
return -1;
}
track_t first_track = cdio_get_first_track_num (info->cdio);
if (first_track == 0xff) {
trace ("cdda: no medium found\n");
return -1;
}
track_t tracks = cdio_get_num_tracks (info->cdio);
track_t i;
cddb_track_t *track;
cddb_disc_t *disc = cddb_disc_new();
cddb_disc_set_length (disc, cdio_get_track_lba (info->cdio, CDIO_CDROM_LEADOUT_TRACK) / CDIO_CD_FRAMES_PER_SEC);
for (i = 0; i < tracks; i++)
{
lsn_t offset = cdio_get_track_lba (info->cdio, i+first_track);
track = cddb_track_new();
cddb_track_set_frame_offset (track, offset);
cddb_disc_add_track (disc, track);
}
cddb_disc_calc_discid (disc);
int discid = cddb_disc_get_discid (disc);
int trk_discid = deadbeef->pl_find_meta_int (it, ":CDIO_DISCID", 0);
if (trk_discid != discid) {
cddb_disc_destroy (disc);
trace ("cdda: the track belongs to another disc, skipped\n");
return -1;
}
cddb_disc_destroy (disc);
if (TRACK_FORMAT_AUDIO != cdio_get_track_format (info->cdio, track_nr))
{
trace ("cdda: Not an audio track (%d)\n", track_nr);
return -1;
}
int channels = cdio_get_track_channels (info->cdio, track_nr);
trace ("cdio nchannels: %d\n", channels);
_info->plugin = &plugin;
_info->fmt.bps = 16;
_info->fmt.channels = 2;
_info->fmt.samplerate = 44100;
_info->fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT;
_info->readpos = 0;
info->first_sector = cdio_get_track_lsn (info->cdio, track_nr);
info->sector_count = cdio_get_track_sec_count (info->cdio, track_nr);
info->current_sector = info->first_sector;
info->tail_len = 0;
info->current_sample = 0;
return 0;
}
static DB_playItem_t *
cda_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
trace ("CDA insert: %s\n", fname);
CdIo_t* cdio = NULL;
int track_nr;
DB_playItem_t *res;
const char* shortname = strrchr (fname, '/');
if (shortname) {
shortname++;
}
else {
shortname = fname;
}
const char *ext = strrchr (shortname, '.') + 1;
int is_image = ext && (0 == strcmp (ext, "nrg"));
if (is_image && !deadbeef->conf_get_int ("cdda.enable_nrg", 0)) {
return NULL;
}
if (0 == strcmp (ext, "cda")) {
cdio = cdio_open (NULL, DRIVER_UNKNOWN);
}
else if (is_image) {
cdio = cdio_open (fname, DRIVER_NRG);
}
if (!cdio) {
trace ("not an audio disc/image, or file not found (%s)\n", fname);
return NULL;
}
// calculate discid
track_t first_track = cdio_get_first_track_num (cdio);
if (first_track == 0xff) {
trace ("cdda: no medium found\n");
cdio_destroy (cdio);
return NULL;
}
track_t tracks = cdio_get_num_tracks (cdio);
track_t i;
cddb_track_t *track;
cddb_disc_t *disc = cddb_disc_new();
cddb_disc_set_length (disc, cdio_get_track_lba (cdio, CDIO_CDROM_LEADOUT_TRACK) / CDIO_CD_FRAMES_PER_SEC);
for (i = 0; i < tracks; i++)
{
lsn_t offset = cdio_get_track_lba (cdio, i+first_track);
track = cddb_track_new();
cddb_track_set_frame_offset (track, offset);
cddb_disc_add_track (disc, track);
}
cddb_disc_calc_discid (disc);
int discid = cddb_disc_get_discid (disc);
if (0 == strcasecmp (shortname, "all.cda") || is_image)
{
track_t i;
res = after;
struct cddb_thread_params *p = malloc (sizeof (struct cddb_thread_params));
memset (p, 0, sizeof (struct cddb_thread_params));
p->cdio = cdio;
int enable_cddb = deadbeef->conf_get_int ("cdda.freedb.enable", DEFAULT_USE_CDDB);
for (i = 0; i < tracks; i++)
{
trace ("inserting track %d\n", i);
res = insert_single_track (cdio, plt, res, is_image ? fname : NULL, i+first_track, discid);
if (res) {
p->items[i] = res;
}
}
int got_cdtext = read_disc_cdtext (p);
int prefer_cdtext = deadbeef->conf_get_int ("cdda.prefer_cdtext", DEFAULT_PREFER_CDTEXT);
if ((!got_cdtext || !prefer_cdtext) && enable_cddb)
{
trace ("cdda: querying freedb...\n");
intptr_t tid = deadbeef->thread_start (cddb_thread, p); //will destroy cdio
deadbeef->thread_detach (tid);
}
else
cleanup_thread_params (p);
}
else
{
track_nr = atoi (shortname);
res = insert_single_track (cdio, plt, after, NULL, track_nr, discid);
if (res) {
read_track_cdtext (cdio, track_nr, res);
deadbeef->pl_item_unref (res);
}
cdio_destroy (cdio);
}
cddb_disc_destroy (disc);
return res;
}
static int
cda_init (DB_fileinfo_t *_info, DB_playItem_t *it)
{
deadbeef->pl_lock();
const char *uri = deadbeef->pl_find_meta(it, ":URI");
const char *nr = uri ? strchr(uri, '#') : NULL;
if (!nr || nr == uri) {
deadbeef->pl_unlock();
trace ("cdda: bad name: %s\n", uri);
return -1;
}
trace ("cdda: init %s\n", uri);
const int track_nr = atoi(nr+1);
const size_t device_length = nr - uri;
char device[device_length+1];
strncpy(device, uri, device_length);
device[device_length] = '\0';
deadbeef->pl_unlock();
cdda_info_t *info = (cdda_info_t *)_info;
info->cdio = cdio_open(device, DRIVER_UNKNOWN);
if (!info->cdio) {
trace ("cdda: Could not open CD device\n");
return -1;
}
const int need_bitrate = info->hints & DDB_DECODER_HINT_NEED_BITRATE;
const int drive_speed = deadbeef->conf_get_int("cdda.drive_speed", 2);
cdio_set_speed(info->cdio, need_bitrate && drive_speed < 5 ? 1<<drive_speed : -1);
cddb_disc_t *disc = create_disc(info->cdio);
if (!disc) {
return -1;
}
const unsigned long discid = cddb_disc_get_discid(disc);
cddb_disc_destroy(disc);
deadbeef->pl_lock();
const char *discid_hex = deadbeef->pl_find_meta(it, CDDB_DISCID_TAG);
const unsigned long trk_discid = discid_hex ? strtoul(discid_hex, NULL, 16) : 0;
deadbeef->pl_unlock();
if (trk_discid != discid) {
trace ("cdda: the track belongs to another disc (%x vs %x), skipped\n", trk_discid, discid);
return -1;
}
if (cdio_get_track_format(info->cdio, track_nr) != TRACK_FORMAT_AUDIO) {
trace ("cdda: Not an audio track (%d)\n", track_nr);
return -1;
}
info->first_sector = cdio_get_track_lsn(info->cdio, track_nr);
info->current_sector = info->first_sector;
info->last_sector = info->first_sector + cdio_get_track_sec_count(info->cdio, track_nr) - 1;
trace("cdio nchannels (should always be 2 for an audio track): %d\n", cdio_get_track_channels (info->cdio, track_nr));
if (info->first_sector == CDIO_INVALID_LSN || info->last_sector <= info->first_sector) {
trace ("cdda: invalid track\n");
return -1;
}
#if USE_PARANOIA
if (cdio_get_driver_id(info->cdio) != DRIVER_NRG) {
info->cdrom = cdda_identify(device, CDDA_MESSAGE_FORGETIT, NULL);
if (info->cdrom) {
cdda_open(info->cdrom);
info->paranoia = paranoia_init(info->cdrom);
}
if (!info->paranoia) {
trace ("cdda: cannot re-open %s for paranoia\n", device);
return -1;
}
const int no_paranoia = need_bitrate || !deadbeef->conf_get_int("cdda.paranoia", 0);
if (no_paranoia) {
paranoia_cachemodel_size(info->paranoia, 100);
}
paranoia_modeset(info->paranoia, no_paranoia ? PARANOIA_MODE_DISABLE : PARANOIA_MODE_FULL^PARANOIA_MODE_NEVERSKIP);
paranoia_seek(info->paranoia, info->first_sector, SEEK_SET);
}
#endif
return 0;
}
bool AudioCDDemux::freedb_query( cddb_disc_t *&cddb_disc )
{
#ifdef Q_OS_WIN
bool hasHomeEnv = getenv( "HOME" );
if ( !hasHomeEnv )
putenv( "HOME=" + QDir::homePath().toLocal8Bit() );
#endif
cddb_conn_t *cddb = cddb_new();
#ifdef Q_OS_WIN
if ( !hasHomeEnv )
putenv( "HOME=" );
#endif
cddb_disc = cddb_disc_new();
#ifdef Q_OS_WIN
const QString cddbDir = QMPlay2Core.getSettingsDir() + "CDDB";
if ( QDir( cddbDir ).exists() || QDir( QMPlay2Core.getSettingsDir() ).mkdir( "CDDB" ) )
cddb_cache_set_dir( cddb, cddbDir.toLocal8Bit() );
#endif
cddb_disc_set_length( cddb_disc, FRAMES_TO_SECONDS( cdio_get_track_lba( cdio, CDIO_CDROM_LEADOUT_TRACK ) ) );
for ( int trackno = 1 ; trackno <= numTracks ; ++trackno )
{
cddb_track_t *pcddb_track = cddb_track_new();
cddb_track_set_frame_offset( pcddb_track, cdio_get_track_lba( cdio, trackno ) );
cddb_disc_add_track( cddb_disc, pcddb_track );
}
bool useNetwork = false;
cddb_disc_calc_discid( cddb_disc );
if ( cddb_disc_get_discid( cddb_disc ) == discID )
cddb_cache_only( cddb );
else
{
discID = cddb_disc_get_discid( cddb_disc );
cddb_set_timeout( cddb, 3 );
cddb_http_enable( cddb );
cddb_set_server_port( cddb, 80 );
Settings sets( "QMPlay2" );
if ( sets.getBool( "Proxy/Use" ) )
{
cddb_http_proxy_enable( cddb );
cddb_set_http_proxy_server_name( cddb, sets.getString( "Proxy/Host" ).toLocal8Bit() );
cddb_set_http_proxy_server_port( cddb, sets.getUInt( "Proxy/Port" ) );
if ( sets.getBool( "Proxy/Login" ) )
{
cddb_set_http_proxy_username( cddb, sets.getString( "Proxy/User" ).toLocal8Bit() );
cddb_set_http_proxy_password( cddb, QString( QByteArray::fromBase64( sets.getByteArray( "Proxy/Password" ) ) ).toLocal8Bit() );
}
}
useNetwork = true;
}
for ( int i = 0 ; i <= useNetwork ; ++i )
{
if ( cddb_query( cddb, cddb_disc ) > 0 )
{
do if ( cddb_disc_get_discid( cddb_disc ) == discID )
{
cddb_read( cddb, cddb_disc );
cddb_destroy( cddb );
return true;
} while ( cddb_query_next( cddb, cddb_disc ) );
}
if ( useNetwork && !i )
cddb_set_server_name( cddb, "freedb.musicbrainz.org" );
}
cddb_disc_destroy( cddb_disc );
cddb_destroy( cddb );
cddb_disc = NULL;
return false;
}
/* 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;
}
void do_query(cddb_conn_t *conn, cddb_disc_t *disc, int quiet)
{
int matches, i;
/* This command also requires the disc ID to be initalized
correctly. So we first calculate this disc ID before executing
the query command. */
cddb_disc_calc_discid(disc);
/* Try querying the database for information about the provided
disc. This function will return the number of matches that
were found. A return value of 0 means that no matches were
found. The data of the first match (when found) will be filled
in into the disc structure passed to it. The information will
be retrieved from the server or read from the cache depending
on the connection settings. */
matches = cddb_query(conn, disc);
/* If an error occured then the return value will be -1 and the
internal libcddb error number will be set. */
if (matches == -1) {
/* Print an explanatory message on stderr. Other routines are
available for retrieving the message without printing it or
printing it on a stream other than stderr. */
if (!quiet) {
cddb_error_print(cddb_errno(conn));
}
/* Return to calling fucntion. */
return;
}
printf("Number of matches: %d\n", matches);
/* A CDDB query command will not return all the disc information.
It will return a subset that can afterwards be used to do a
CDDB read. This enables you to first show a pop-up listing the
found matches before doing further reads for the full data.
The data that is returned for each match is: the disc CDDB
category, the disc ID as known by the server, the disc title
and the artist's name. */
/* Let's loop over the matches. */
i = 0;
while (i < matches) {
/* Increment the match counter. */
i++;
/* Print out the information for the current match. */
printf("Match %d\n", i);
/* Retrieve and print the category and disc ID. */
printf(" category: %s (%d)\t%08x\n", cddb_disc_get_category_str(disc),
cddb_disc_get_category(disc), cddb_disc_get_discid(disc));
/* Retrieve and print the disc title and artist name. */
printf(" '%s' by %s\n", cddb_disc_get_title(disc),
cddb_disc_get_artist(disc));
/* Get the next match, if there is one left. */
if (i < matches) {
/* If there are multiple matches, then you can use the
following function to retrieve the matches beyond the
first. This function will overwrite any data that
might be present in the disc structure passed to it.
So if you still need that disc for anything else, then
first create a new disc and use that to call this
function. If there are no more matches left, false
(i.e. 0) will be returned. */
if (!cddb_query_next(conn, disc)) {
error_exit(cddb_errno(conn), "query index out of bounds");
}
}
}
}