CddbConnection(cddb_disc_t *d) : disc(0) {
connection = cddb_new();
if (connection) {
cddb_cache_disable(connection);
cddb_set_server_name(connection, Settings::self()->cddbHost().toLatin1().constData());
cddb_set_server_port(connection, Settings::self()->cddbPort());
disc=cddb_disc_clone(d);
#ifdef ENABLE_KDE_SUPPORT
QString proxy=KProtocolManager::proxyFor("http");
if (!proxy.isEmpty()) {
QUrl url(proxy);
cddb_set_http_proxy_server_name(connection, url.host().toLatin1().constData());
cddb_set_http_proxy_server_port(connection, url.port());
cddb_http_proxy_enable(connection);
}
#else
QUrl url;
url.setHost(Settings::self()->cddbHost());
url.setPort(Settings::self()->cddbPort());
QList<QNetworkProxy> proxies=NetworkProxyFactory::self()->queryProxy(QNetworkProxyQuery(url));
foreach (const QNetworkProxy &p, proxies) {
if (QNetworkProxy::HttpProxy==p.type() && 0!=p.port()) {
cddb_set_http_proxy_server_name(connection, p.hostName().toLatin1().constData());
cddb_set_http_proxy_server_port(connection, p.port());
cddb_http_proxy_enable(connection);
break;
}
}
#endif
}
}
static void
parse_cddb (cdda_t *cd)
{
cddb_disc_t *disc;
cddb_conn_t *conn;
int res;
if (!cd)
return;
libcddb_init ();
conn = cddb_new ();
disc = cddb_disc_new ();
cddb_disc_set_category_str (disc, "misc");
cddb_disc_set_discid (disc, cd->id);
res = cddb_read (conn, disc);
if (!res)
goto err_cddb_read;
cd_get_metadata (cd, disc);
cd_get_tracks (cd, disc);
err_cddb_read:
cddb_disc_destroy (disc);
libcddb_shutdown ();
}
cddb_disc_t*
resolve_disc (CdIo_t *cdio)
{
track_t first_track = cdio_get_first_track_num (cdio);
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_conn_t *conn = NULL;
conn = cddb_new();
deadbeef->conf_lock ();
cddb_set_server_name (conn, deadbeef->conf_get_str_fast ("cdda.freedb.host", DEFAULT_SERVER));
cddb_set_server_port (conn, deadbeef->conf_get_int ("cdda.freedb.port", DEFAULT_PORT));
if (!deadbeef->conf_get_int ("cdda.protocol", DEFAULT_PROTOCOL))
{
cddb_http_enable (conn);
if (deadbeef->conf_get_int ("network.proxy", 0))
{
cddb_set_server_port(conn, deadbeef->conf_get_int ("network.proxy.port", 8080));
cddb_set_server_name(conn, deadbeef->conf_get_str_fast ("network.proxy.address", ""));
}
}
deadbeef->conf_unlock ();
int matches = cddb_query (conn, disc);
if (matches == -1)
{
cddb_disc_destroy (disc);
cddb_destroy (conn);
return NULL;
}
cddb_read (conn, disc);
cddb_destroy (conn);
return disc;
}
/* initialize connection to cddb server */
cddb_conn_t *init_conn() {
cddb_conn_t *conn;
if ((conn = cddb_new()) == NULL) {
fprintf(stderr, "out of memory, "
"unable to create connection structure");
}
/* HTTP settings */
cddb_http_enable(conn);
cddb_set_server_port(conn, 80);
cddb_set_server_name(conn, "freedb.org");
cddb_set_http_path_query(conn, "/~cddb/cddb.cgi");
cddb_set_http_path_submit(conn, "/~cddb/submit.cgi");
return conn;
}
/**
* Given a CDIO device, calculates the necessary information about the device
* and contacts a CDDB server to get disk information.
*
* @param p_cdio a CDIO device
* @param disk the disk structure to store the information in
*
* @return an error status about whether information was obtained
*/
enum giles_cddb_err get_cddb_info_for_device(const CdIo_t *p_cdio, cddb_disc_t *disc) {
lsn_t last_lsn;
msf_t last_msf;
unsigned disc_len_in_s, i, matches;
track_t num_tracks;
cddb_track_t *track;
cddb_conn_t *conn;
num_tracks = cdio_get_num_tracks(p_cdio);
DPRINTF ("Disc contains %d tracks\n", num_tracks);
for (i = 1; i <= num_tracks; i++) {
track = cddb_track_new();
cddb_track_set_frame_offset(track, cdio_get_track_lba(p_cdio, i));
DPRINTF ("Offset for track %d is %d\n", i, cdio_get_track_lba(p_cdio, i));
cddb_disc_add_track(disc, track);
}
last_lsn = cdio_get_disc_last_lsn(p_cdio);
cdio_lsn_to_msf(last_lsn, &last_msf);
disc_len_in_s = cdio_audio_get_msf_seconds(&last_msf);
cddb_disc_set_length(disc, disc_len_in_s);
conn = cddb_new();
if (conn == NULL) {
cddb_error_print(cddb_errno(conn));
return giles_cddb_err_no_conn;
}
matches = cddb_query(conn, disc);
if (matches == -1) {
return giles_cddb_err_no_conn;
} else if (matches == 0) {
return giles_cddb_err_no_match;
}
cddb_read(conn, disc);
cddb_destroy(conn);
return giles_cddb_err_none;
}
static cddb_conn_t *
new_cddb_connection(void)
{
cddb_conn_t *conn = cddb_new();
if (conn) {
deadbeef->conf_lock ();
cddb_set_server_name (conn, deadbeef->conf_get_str_fast ("cdda.freedb.host", DEFAULT_SERVER));
cddb_set_server_port (conn, deadbeef->conf_get_int ("cdda.freedb.port", DEFAULT_PORT));
if (!deadbeef->conf_get_int ("cdda.protocol", DEFAULT_PROTOCOL)) {
cddb_http_enable (conn);
if (deadbeef->conf_get_int ("network.proxy", 0)) {
cddb_set_server_port(conn, deadbeef->conf_get_int ("network.proxy.port", 8080));
cddb_set_server_name(conn, deadbeef->conf_get_str_fast ("network.proxy.address", ""));
}
}
deadbeef->conf_unlock ();
}
return conn;
}
CddbConnection(cddb_disc_t *d) : disc(0) {
connection = cddb_new();
if (connection) {
cddb_cache_disable(connection);
cddb_set_server_name(connection, Settings::self()->cddbHost().toLatin1().constData());
cddb_set_server_port(connection, Settings::self()->cddbPort());
disc=cddb_disc_clone(d);
QUrl url;
url.setHost(Settings::self()->cddbHost());
url.setPort(Settings::self()->cddbPort());
QList<QNetworkProxy> proxies=NetworkProxyFactory::self()->queryProxy(QNetworkProxyQuery(url));
foreach (const QNetworkProxy &p, proxies) {
if (QNetworkProxy::HttpProxy==p.type() && 0!=p.port()) {
cddb_set_http_proxy_server_name(connection, p.hostName().toLatin1().constData());
cddb_set_http_proxy_server_port(connection, p.port());
cddb_http_proxy_enable(connection);
break;
}
}
}
}
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;
}
static cddb_disc_t *GetCDDBInfo( access_t *p_access, int i_titles, int *p_sectors )
{
if( var_InheritInteger( p_access, "album-art" ) == ALBUM_ART_WHEN_ASKED )
return NULL;
/* */
cddb_conn_t *p_cddb = cddb_new();
if( !p_cddb )
{
msg_Warn( p_access, "unable to use CDDB" );
return NULL;
}
/* */
cddb_http_enable( p_cddb );
char *psz_tmp = var_InheritString( p_access, "cddb-server" );
if( psz_tmp )
{
cddb_set_server_name( p_cddb, psz_tmp );
free( psz_tmp );
}
cddb_set_server_port( p_cddb, var_InheritInteger( p_access, "cddb-port" ) );
cddb_set_email_address( p_cddb, "*****@*****.**" );
cddb_set_http_path_query( p_cddb, "/~cddb/cddb.cgi" );
cddb_set_http_path_submit( p_cddb, "/~cddb/submit.cgi" );
char *psz_cachedir;
char *psz_temp = config_GetUserDir( VLC_CACHE_DIR );
if( asprintf( &psz_cachedir, "%s" DIR_SEP "cddb", psz_temp ) > 0 ) {
cddb_cache_enable( p_cddb );
cddb_cache_set_dir( p_cddb, psz_cachedir );
free( psz_cachedir );
}
free( psz_temp );
cddb_set_timeout( p_cddb, 10 );
/* */
cddb_disc_t *p_disc = cddb_disc_new();
if( !p_disc )
{
msg_Err( p_access, "unable to create CDDB disc structure." );
goto error;
}
int64_t i_length = 0;
for( int i = 0; i < i_titles; i++ )
{
cddb_track_t *t = cddb_track_new();
cddb_track_set_frame_offset( t, p_sectors[i] );
cddb_disc_add_track( p_disc, t );
const int64_t i_size = ( p_sectors[i+1] - p_sectors[i] ) *
(int64_t)CDDA_DATA_SIZE;
i_length += INT64_C(1000000) * i_size / 44100 / 4 ;
}
cddb_disc_set_length( p_disc, (int)(i_length/1000000) );
if( !cddb_disc_calc_discid( p_disc ) )
{
msg_Err( p_access, "CDDB disc ID calculation failed" );
goto error;
}
const int i_matches = cddb_query( p_cddb, p_disc );
if( i_matches < 0 )
{
msg_Warn( p_access, "CDDB error: %s", cddb_error_str((cddb_error_t)errno) ); // sunqueen modify
goto error;
}
else if( i_matches == 0 )
{
msg_Dbg( p_access, "Couldn't find any matches in CDDB." );
goto error;
}
else if( i_matches > 1 )
msg_Warn( p_access, "found %d matches in CDDB. Using first one.", i_matches );
cddb_read( p_cddb, p_disc );
cddb_destroy( p_cddb);
return p_disc;
error:
if( p_disc )
cddb_disc_destroy( p_disc );
cddb_destroy( p_cddb );
return NULL;
}
/* 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;
}
static void
print_cddb_info(CdIo_t *p_cdio, track_t i_tracks, track_t i_first_track) {
int i, matches;
cddb_conn_t *conn = cddb_new();
cddb_disc_t *disc = NULL;
if (!conn) {
report(stderr, "%s: unable to initialize libcddb\n", program_name);
goto cddb_destroy;
}
if (NULL == opts.cddb_email)
cddb_set_email_address(conn, "me@home");
else
cddb_set_email_address(conn, opts.cddb_email);
if (NULL == opts.cddb_server)
cddb_set_server_name(conn, "freedb.freedb.org");
else
cddb_set_server_name(conn, opts.cddb_server);
if (opts.cddb_timeout >= 0)
cddb_set_timeout(conn, opts.cddb_timeout);
cddb_set_server_port(conn, opts.cddb_port);
if (opts.cddb_http)
cddb_http_enable(conn);
else
cddb_http_disable(conn);
if (NULL != opts.cddb_cachedir)
cddb_cache_set_dir(conn, opts.cddb_cachedir);
if (opts.cddb_disable_cache)
cddb_cache_disable(conn);
disc = cddb_disc_new();
if (!disc) {
report(stderr, "%s: unable to create CDDB disc structure", program_name);
goto cddb_destroy;
}
for(i = 0; i < i_tracks; i++) {
cddb_track_t *t = cddb_track_new();
t->frame_offset = cdio_get_track_lba(p_cdio, i+i_first_track);
cddb_disc_add_track(disc, t);
}
disc->length =
cdio_get_track_lba(p_cdio, CDIO_CDROM_LEADOUT_TRACK)
/ CDIO_CD_FRAMES_PER_SEC;
if (!cddb_disc_calc_discid(disc)) {
report(stderr, "%s: libcddb calc discid failed.\n",
program_name);
goto cddb_destroy;
}
matches = cddb_query(conn, disc);
if (-1 == matches)
{
sprintf(temp_msg, "%s: %s\n", program_name, cddb_error_str(cddb_errno(conn)));
report(stdout, temp_msg);
}
else {
sprintf(temp_msg, "%s: Found %d matches in CDDB\n", program_name, matches);
report(stdout, temp_msg);
for (i=1; i<=matches; i++) {
cddb_read(conn, disc);
cddb_disc_print(disc);
cddb_query_next(conn, disc);
}
}
cddb_disc_destroy(disc);
cddb_destroy:
cddb_destroy(conn);
}