static cddb_disc_t *
create_disc(CdIo_t *cdio)
{
cddb_disc_t *disc = cddb_disc_new();
if (disc) {
const lba_t leadout_lba = cdio_get_track_lba(cdio, CDIO_CDROM_LEADOUT_TRACK);
cddb_disc_set_length(disc, leadout_lba / CDIO_CD_FRAMES_PER_SEC);
const track_t first_track = cdio_get_first_track_num(cdio);
const track_t num_tracks = cdio_get_num_tracks(cdio);
if (leadout_lba == CDIO_INVALID_LBA || first_track == CDIO_INVALID_TRACK || num_tracks == CDIO_INVALID_TRACK) {
trace("cda: create_disc failed, invalid CD disc format\n");
cddb_disc_destroy(disc);
return NULL;
}
const track_t last_track = first_track + num_tracks;
for (track_t i = first_track; i < last_track; i++) {
cddb_track_t *track = cddb_track_new();
if (!track) {
cddb_disc_destroy(disc);
return NULL;
}
const lba_t offset = cdio_get_track_lba(cdio, i);
cddb_track_set_frame_offset(track, offset);
cddb_disc_add_track(disc, track);
}
cddb_disc_calc_discid(disc);
}
return disc;
}
CddbInterface::~CddbInterface()
{
thread->stop();
if (disc) {
cddb_disc_destroy(disc);
}
}
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 ();
}
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 void
print_cddb_info(CdIo_t *p_cdio, track_t i_tracks, track_t i_first_track)
{
int i, i_cddb_matches = 0;
cddb_conn_t *p_conn = NULL;
cddb_disc_t *p_cddb_disc = NULL;
if ( init_cddb(p_cdio, &p_conn, &p_cddb_disc, cddb_errmsg, i_first_track,
i_tracks, &i_cddb_matches) ) {
if (-1 == i_cddb_matches)
printf("%s: %s\n", program_name, cddb_error_str(cddb_errno(p_conn)));
else {
printf("%s: Found %d matches in CDDB\n", program_name, i_cddb_matches);
for (i=1; i<=i_cddb_matches; i++) {
cddb_disc_print(p_cddb_disc);
cddb_query_next(p_conn, p_cddb_disc);
if (i != i_cddb_matches) cddb_read(p_conn, p_cddb_disc);
}
}
cddb_disc_destroy(p_cddb_disc);
cddb_destroy(p_conn);
libcddb_shutdown();
}
}
~CddbConnection() {
if (disc) {
cddb_disc_destroy(disc);
}
if (connection) {
cddb_destroy(connection);
}
}
static void
cddb_thread (void *items_i)
{
struct cddb_thread_params *params = (struct cddb_thread_params*)items_i;
DB_playItem_t **items = params->items;
trace ("calling resolve_disc\n");
cddb_disc_t* disc = resolve_disc (params->cdio);
if (!disc)
{
trace ("disc not resolved\n");
if (params->cdio) {
cdio_destroy (params->cdio);
}
free (params);
return;
}
trace ("disc resolved\n");
const char *disc_title = cddb_disc_get_title (disc);
const char *artist = cddb_disc_get_artist (disc);
trace ("disc_title=%s, disk_artist=%s\n", disc_title, artist);
cddb_track_t *track;
int i;
// FIXME: playlist must be locked before doing that
int trk = 1;
for (i = 0, track = cddb_disc_get_track_first (disc); items[i]; trk++, ++i, track = cddb_disc_get_track_next (disc))
{
// FIXME: problem will happen here if item(s) were deleted from playlist, and new items were added in their places
// possible solutions: catch EV_TRACKDELETED and mark item(s) in every thread as NULL
trace ("track %d, artist=%s, album=%s, title=%s\n", i, artist, disc_title, cddb_track_get_title (track));
deadbeef->pl_delete_all_meta (items[i]);
deadbeef->pl_add_meta (items[i], "artist", artist);
deadbeef->pl_add_meta (items[i], "album", disc_title);
deadbeef->pl_add_meta (items[i], "title", cddb_track_get_title (track));
char tmp[5];
snprintf (tmp, sizeof (tmp), "%02d", trk);
deadbeef->pl_add_meta (items[i], "track", tmp);
ddb_event_track_t *ev = (ddb_event_track_t *)deadbeef->event_alloc (DB_EV_TRACKINFOCHANGED);
ev->track = items[i];
if (ev->track) {
deadbeef->pl_item_ref (ev->track);
}
deadbeef->event_send ((ddb_event_t *)ev, 0, 0);
}
cddb_disc_destroy (disc);
cleanup_thread_params (params);
ddb_playlist_t *plt = deadbeef->plt_get_curr ();
if (plt) {
deadbeef->plt_modified (plt);
deadbeef->plt_unref (plt);
}
deadbeef->sendmessage (DB_EV_PLAYLISTCHANGED, 0, 0, 0);
}
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;
}
static void
cleanup_thread_params (struct cddb_thread_params *params)
{
trace("cleanup_thread_params\n");
if (params->items) {
for (size_t i = 0; params->items[i]; i++) {
deadbeef->pl_item_unref(params->items[i]);
}
free(params->items);
}
if (params->disc) {
cddb_disc_destroy(params->disc);
}
free(params);
}
static void
finish(const char *psz_msg, int rc)
{
if (b_interactive) {
attron(A_STANDOUT);
mvprintw(LINE_ACTION, 0, (char *) "%s, exiting...\n", psz_msg);
attroff(A_STANDOUT);
clrtoeol();
refresh();
}
tty_restore();
#ifdef HAVE_CDDB
if (p_conn) cddb_destroy(p_conn);
cddb_disc_destroy(p_cddb_disc);
libcddb_shutdown();
#endif /*HAVE_CDDB*/
cdio_destroy (p_cdio);
free (psz_device);
exit (rc);
}
QList< Playlist::Entry > AudioCDDemux::getTracks( const QString &_device )
{
QList< Playlist::Entry > tracks;
Playlist::Entry entry;
device = _device;
cdio_close_tray( device.toLocal8Bit(), NULL );
if ( ( cdio = cdio_open( device.toLocal8Bit(), DRIVER_UNKNOWN ) ) )
{
numTracks = cdio_get_num_tracks( cdio );
if ( cdio_get_discmode( cdio ) != CDIO_DISC_MODE_ERROR && numTracks > 0 && numTracks != CDIO_INVALID_TRACK )
{
cddb_disc_t *cddb_disc = NULL;
bool cddb_ok = useCDDB;
for ( trackNo = 1 ; trackNo <= numTracks ; ++trackNo )
{
chn = cdio_get_track_channels( cdio, trackNo );
if ( chn != 2 && chn != 4 )
continue;
if ( useCDTEXT )
readCDText( trackNo );
isData = cdio_get_track_format( cdio, trackNo ) != TRACK_FORMAT_AUDIO;
duration = CD_BLOCKSIZE / chn / ( double )srate;
numSectors = cdio_get_track_last_lsn( cdio, trackNo ) - cdio_get_track_lsn( cdio, trackNo );
if ( cddb_ok && ( cddb_disc || ( Title.isEmpty() && ( cddb_ok = freedb_query( cddb_disc ) ) ) ) )
freedb_get_track_info( cddb_disc );
entry.name = title();
entry.url = AudioCDName"://" + QString::number( trackNo ) + "?device=" + device;
entry.length = length();
tracks += entry;
}
cddb_disc_destroy( cddb_disc );
}
}
return tracks;
}
static int GetTracks( access_t *p_access, input_item_t *p_current )
{
access_sys_t *p_sys = p_access->p_sys;
const int i_titles = ioctl_GetTracksMap( VLC_OBJECT(p_access),
p_sys->vcddev, &p_sys->p_sectors );
if( i_titles <= 0 )
{
if( i_titles < 0 )
msg_Err( p_access, "unable to count tracks" );
else if( i_titles <= 0 )
msg_Err( p_access, "no audio tracks found" );
return VLC_EGENERIC;;
}
/* */
input_item_SetName( p_current, "Audio CD" );
const char *psz_album = NULL;
const char *psz_year = NULL;
const char *psz_genre = NULL;
const char *psz_artist = NULL;
const char *psz_description = NULL;
/* Return true if the given string is not NULL and not empty */
#define NONEMPTY( psz ) ( (psz) && *(psz) )
/* If the given string is NULL or empty, fill it by the return value of 'code' */
#define ON_EMPTY( psz, code ) do { if( !NONEMPTY( psz) ) { (psz) = code; } } while(0)
/* Retreive CDDB information */
#ifdef HAVE_LIBCDDB
char psz_year_buffer[4+1];
msg_Dbg( p_access, "fetching infos with CDDB" );
cddb_disc_t *p_disc = GetCDDBInfo( p_access, i_titles, p_sys->p_sectors );
if( p_disc )
{
psz_album = cddb_disc_get_title( p_disc );
psz_genre = cddb_disc_get_genre( p_disc );
/* */
const unsigned i_year = cddb_disc_get_year( p_disc );
if( i_year > 0 )
{
psz_year = psz_year_buffer;
snprintf( psz_year_buffer, sizeof(psz_year_buffer), "%u", i_year );
}
/* Set artist only if unique */
for( int i = 0; i < i_titles; i++ )
{
cddb_track_t *t = cddb_disc_get_track( p_disc, i );
if( !t )
continue;
const char *psz_track_artist = cddb_track_get_artist( t );
if( psz_artist && psz_track_artist &&
strcmp( psz_artist, psz_track_artist ) )
{
psz_artist = NULL;
break;
}
psz_artist = psz_track_artist;
}
}
#endif
/* CD-Text */
vlc_meta_t **pp_cd_text;
int i_cd_text;
if( ioctl_GetCdText( VLC_OBJECT(p_access), p_sys->vcddev, &pp_cd_text, &i_cd_text ) )
{
msg_Dbg( p_access, "CD-TEXT information missing" );
i_cd_text = 0;
pp_cd_text = NULL;
}
/* Retrieve CD-TEXT information but prefer CDDB */
if( i_cd_text > 0 && pp_cd_text[0] )
{
const vlc_meta_t *p_disc = pp_cd_text[0];
ON_EMPTY( psz_album, vlc_meta_Get( p_disc, vlc_meta_Album ) );
ON_EMPTY( psz_genre, vlc_meta_Get( p_disc, vlc_meta_Genre ) );
ON_EMPTY( psz_artist, vlc_meta_Get( p_disc, vlc_meta_Artist ) );
ON_EMPTY( psz_description, vlc_meta_Get( p_disc, vlc_meta_Description ) );
}
if( NONEMPTY( psz_album ) )
{
input_item_SetName( p_current, psz_album );
input_item_SetAlbum( p_current, psz_album );
}
if( NONEMPTY( psz_genre ) )
input_item_SetGenre( p_current, psz_genre );
if( NONEMPTY( psz_artist ) )
input_item_SetArtist( p_current, psz_artist );
if( NONEMPTY( psz_year ) )
input_item_SetDate( p_current, psz_year );
if( NONEMPTY( psz_description ) )
input_item_SetDescription( p_current, psz_description );
const mtime_t i_duration = (int64_t)( p_sys->p_sectors[i_titles] - p_sys->p_sectors[0] ) *
CDDA_DATA_SIZE * 1000000 / 44100 / 2 / 2;
input_item_SetDuration( p_current, i_duration );
input_item_node_t *p_root = input_item_node_Create( p_current );
/* Build title table */
for( int i = 0; i < i_titles; i++ )
{
input_item_t *p_input_item;
char *psz_uri, *psz_opt, *psz_first, *psz_last;
char *psz_name;
msg_Dbg( p_access, "track[%d] start=%d", i, p_sys->p_sectors[i] );
/* */
if( asprintf( &psz_uri, "cdda://%s", p_access->psz_location ) == -1 )
psz_uri = NULL;
if( asprintf( &psz_opt, "cdda-track=%i", i+1 ) == -1 )
psz_opt = NULL;
if( asprintf( &psz_first, "cdda-first-sector=%i",p_sys->p_sectors[i] ) == -1 )
psz_first = NULL;
if( asprintf( &psz_last, "cdda-last-sector=%i", p_sys->p_sectors[i+1] ) == -1 )
psz_last = NULL;
/* Define a "default name" */
if( asprintf( &psz_name, _("Audio CD - Track %02i"), (i+1) ) == -1 )
psz_name = NULL;
/* Create playlist items */
const mtime_t i_duration = (int64_t)( p_sys->p_sectors[i+1] - p_sys->p_sectors[i] ) *
CDDA_DATA_SIZE * 1000000 / 44100 / 2 / 2;
p_input_item = input_item_NewWithType( psz_uri, psz_name, 0, NULL, 0,
i_duration, ITEM_TYPE_DISC );
input_item_CopyOptions( p_current, p_input_item );
input_item_AddOption( p_input_item, psz_first, VLC_INPUT_OPTION_TRUSTED );
input_item_AddOption( p_input_item, psz_last, VLC_INPUT_OPTION_TRUSTED );
input_item_AddOption( p_input_item, psz_opt, VLC_INPUT_OPTION_TRUSTED );
const char *psz_track_title = NULL;
const char *psz_track_artist = NULL;
const char *psz_track_genre = NULL;
const char *psz_track_description = NULL;
#ifdef HAVE_LIBCDDB
/* Retreive CDDB information */
if( p_disc )
{
cddb_track_t *t = cddb_disc_get_track( p_disc, i );
if( t != NULL )
{
psz_track_title = cddb_track_get_title( t );
psz_track_artist = cddb_track_get_artist( t );
}
}
#endif
/* Retreive CD-TEXT information but prefer CDDB */
if( i+1 < i_cd_text && pp_cd_text[i+1] )
{
const vlc_meta_t *t = pp_cd_text[i+1];
ON_EMPTY( psz_track_title, vlc_meta_Get( t, vlc_meta_Title ) );
ON_EMPTY( psz_track_artist, vlc_meta_Get( t, vlc_meta_Artist ) );
ON_EMPTY( psz_track_genre, vlc_meta_Get( t, vlc_meta_Genre ) );
ON_EMPTY( psz_track_description, vlc_meta_Get( t, vlc_meta_Description ) );
}
/* */
ON_EMPTY( psz_track_artist, psz_artist );
ON_EMPTY( psz_track_genre, psz_genre );
ON_EMPTY( psz_track_description, psz_description );
/* */
if( NONEMPTY( psz_track_title ) )
{
input_item_SetName( p_input_item, psz_track_title );
input_item_SetTitle( p_input_item, psz_track_title );
}
if( NONEMPTY( psz_track_artist ) )
input_item_SetArtist( p_input_item, psz_track_artist );
if( NONEMPTY( psz_track_genre ) )
input_item_SetGenre( p_input_item, psz_track_genre );
if( NONEMPTY( psz_track_description ) )
input_item_SetDescription( p_input_item, psz_track_description );
if( NONEMPTY( psz_album ) )
input_item_SetAlbum( p_input_item, psz_album );
if( NONEMPTY( psz_year ) )
input_item_SetDate( p_input_item, psz_year );
char psz_num[3+1];
snprintf( psz_num, sizeof(psz_num), "%d", 1+i );
input_item_SetTrackNum( p_input_item, psz_num );
input_item_node_AppendItem( p_root, p_input_item );
vlc_gc_decref( p_input_item );
free( psz_uri ); free( psz_opt ); free( psz_name );
free( psz_first ); free( psz_last );
}
#undef ON_EMPTY
#undef NONEMPTY
input_item_node_PostAndDelete( p_root );
/* */
for( int i = 0; i < i_cd_text; i++ )
{
vlc_meta_t *p_meta = pp_cd_text[i];
if( !p_meta )
continue;
vlc_meta_Delete( p_meta );
}
free( pp_cd_text );
#ifdef HAVE_LIBCDDB
if( p_disc )
cddb_disc_destroy( p_disc );
#endif
return VLC_SUCCESS;
}
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);
}
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;
}
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 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;
}
bool AudioCDDemux::open( const QString &_url )
{
#ifdef Q_OS_WIN
if ( _url.toLower().contains( QRegExp( "file://\\D:/track\\d\\d.cda" ) ) )
{
QString url = _url;
url.remove( "file://" );
device = url.mid( 0, url.indexOf( '/' ) );
trackNo = url.mid( url.toLower().indexOf( "track" ) + 5, 2 ).toUInt();
}
else
#endif
{
if ( _url.left( 10 ) != "AudioCD://" )
return false;
QUrl url( _url.mid( 10 ) );
device = QUrlQuery( url ).queryItemValue( "device" );
trackNo = url.path().toUInt();
}
if ( trackNo > 0 && trackNo < CDIO_INVALID_TRACK )
{
cdio = destroyTimer.getInstance( device, discID );
if ( cdio || ( cdio = cdio_open( device.toLocal8Bit(), DRIVER_UNKNOWN ) ) )
{
cdio_set_speed( cdio, 1 );
numTracks = cdio_get_num_tracks( cdio );
if ( cdio_get_discmode( cdio ) != CDIO_DISC_MODE_ERROR && numTracks > 0 && numTracks != CDIO_INVALID_TRACK )
{
chn = cdio_get_track_channels( cdio, trackNo );
if ( numTracks >= trackNo && ( chn == 2 || chn == 4 ) )
{
if ( useCDTEXT )
{
readCDText( 0 );
readCDText( trackNo );
}
isData = cdio_get_track_format( cdio, trackNo ) != TRACK_FORMAT_AUDIO;
duration = CD_BLOCKSIZE / chn / ( double )srate;
startSector = cdio_get_track_lsn( cdio, trackNo );
numSectors = cdio_get_track_last_lsn( cdio, trackNo ) - startSector;
if ( useCDDB && Title.isEmpty() )
{
cddb_disc_t *cddb_disc;
if ( freedb_query( cddb_disc ) )
{
if ( cdTitle.isEmpty() && cdArtist.isEmpty() )
freedb_get_disc_info( cddb_disc );
freedb_get_track_info( cddb_disc );
cddb_disc_destroy( cddb_disc );
}
}
StreamInfo *streamInfo = new StreamInfo;
streamInfo->type = QMPLAY2_TYPE_AUDIO;
streamInfo->is_default = true;
streamInfo->sample_rate = srate;
streamInfo->channels = chn;
streams_info += streamInfo;
return true;
}
else
QMPlay2Core.log( tr( "Błąd odczytu ścieżki" ) );
}
else
QMPlay2Core.log( tr( "Brak płyty w napędzie" ) );
}
else
QMPlay2Core.log( tr( "Nieprawidłowa ścieżka do napędu CD" ) );
}
else //dodawanie do listy ścieżek AudioCD
{
#ifndef Q_OS_WIN
device = QUrl( _url ).path();
#else
device = _url.mid( strlen( AudioCDName"://" ), 2 );
#endif
#ifndef Q_OS_WIN
if ( !QFileInfo( device ).isDir() )
#endif
if ( !device.isEmpty() )
{
emit QMPlay2Core.processParam( "DelPlaylistEntries", _url );
QList< Playlist::Entry > entries = getTracks( device );
if ( !entries.isEmpty() && Playlist::write( entries, "file://" + AudioCDPlaylist ) )
{
emit QMPlay2Core.processParam( "open", AudioCDPlaylist );
return true;
}
}
}
return false;
}
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;
}
/* FIXME: Cleanup track refs */
void common_cleanup(struct con_win *cwin)
{
CDEBUG(DBG_INFO, "Cleaning up");
if ((cwin->cstate->state == ST_STOPPED) && (cwin->cstate->curr_mobj_clear))
delete_musicobject(cwin->cstate->curr_mobj);
if ((cwin->cstate->state == ST_PLAYING) || (cwin->cstate->state == ST_PAUSED))
stop_playback(cwin);
save_preferences(cwin);
g_object_unref(cwin->library_store);
g_object_unref(cwin->pixbuf->image_play);
g_object_unref(cwin->pixbuf->image_pause);
if (cwin->pixbuf->pixbuf_app)
g_object_unref(cwin->pixbuf->pixbuf_app);
if (cwin->pixbuf->pixbuf_dir)
g_object_unref(cwin->pixbuf->pixbuf_dir);
if (cwin->pixbuf->pixbuf_artist)
g_object_unref(cwin->pixbuf->pixbuf_artist);
if (cwin->pixbuf->pixbuf_album)
g_object_unref(cwin->pixbuf->pixbuf_album);
if (cwin->pixbuf->pixbuf_track)
g_object_unref(cwin->pixbuf->pixbuf_track);
if (cwin->pixbuf->pixbuf_genre)
g_object_unref(cwin->pixbuf->pixbuf_genre);
g_slice_free(struct pixbuf, cwin->pixbuf);
if (cwin->album_art)
gtk_widget_destroy(cwin->album_art);
if (cwin->cstate->cdda_drive)
cdio_cddap_close(cwin->cstate->cdda_drive);
if (cwin->cstate->cddb_disc)
cddb_disc_destroy(cwin->cstate->cddb_disc);
if (cwin->cstate->cddb_conn) {
cddb_destroy(cwin->cstate->cddb_conn);
libcddb_shutdown();
}
g_free(cwin->cpref->lw.lastfm_user);
g_free(cwin->cpref->lw.lastfm_pass);
#ifdef HAVE_LIBGLYR
g_free(cwin->cpref->cache_folder);
#endif
g_free(cwin->cpref->configrc_file);
g_free(cwin->cpref->installed_version);
g_free(cwin->cpref->audio_sink);
g_free(cwin->cpref->audio_alsa_device);
g_free(cwin->cpref->audio_oss_device);
g_free(cwin->cpref->album_art_pattern);
g_free(cwin->cpref->audio_cd_device);
g_free(cwin->cpref->start_mode);
g_free(cwin->cpref->sidebar_pane);
g_key_file_free(cwin->cpref->configrc_keyfile);
free_str_list(cwin->cpref->library_dir);
free_str_list(cwin->cpref->lib_add);
free_str_list(cwin->cpref->lib_delete);
free_str_list(cwin->cpref->library_tree_nodes);
free_str_list(cwin->cpref->playlist_columns);
g_slist_free(cwin->cpref->playlist_column_widths);
g_slice_free(struct con_pref, cwin->cpref);
g_rand_free(cwin->cstate->rand);
g_free(cwin->cstate->last_folder);
g_mutex_free(cwin->cstate->c_mutex);
/* Hack, hack */
if (g_mutex_trylock(cwin->cstate->l_mutex) == TRUE) {
g_mutex_unlock(cwin->cstate->l_mutex);
g_mutex_free(cwin->cstate->l_mutex);
}
g_cond_free(cwin->cstate->c_cond);
g_slice_free(struct con_state, cwin->cstate);
#ifdef HAVE_LIBGLYR
uninit_glyr_related (cwin);
#endif
g_free(cwin->cdbase->db_file);
sqlite3_close(cwin->cdbase->db);
g_slice_free(struct con_dbase, cwin->cdbase);
if (cwin->cstate->audio_init && cwin->cmixer)
cwin->cmixer->deinit_mixer(cwin);
if (cwin->clibao->ao_dev) {
CDEBUG(DBG_INFO, "Freeing ao dev");
ao_close(cwin->clibao->ao_dev);
}
ao_shutdown();
g_slice_free(struct con_mixer, cwin->cmixer);
g_slice_free(struct con_libao, cwin->clibao);
g_free(cwin->clastfm->session_id);
g_free(cwin->clastfm->submission_url);
if (cwin->clastfm->curl_handle)
curl_easy_cleanup(cwin->clastfm->curl_handle);
curl_global_cleanup();
g_slice_free(struct con_lastfm, cwin->clastfm);
dbus_connection_remove_filter(cwin->con_dbus,
dbus_filter_handler,
cwin);
dbus_bus_remove_match(cwin->con_dbus,
"type='signal',path='/org/pragha/DBus'",
NULL);
dbus_connection_unref(cwin->con_dbus);
#if HAVE_GLIB_2_26
mpris_cleanup(cwin);
#endif
if (notify_is_initted())
notify_uninit();
#ifdef HAVE_LIBKEYBINDER
keybinder_unbind("XF86AudioPlay", (KeybinderHandler) keybind_play_handler);
keybinder_unbind("XF86AudioStop", (KeybinderHandler) keybind_stop_handler);
keybinder_unbind("XF86AudioPrev", (KeybinderHandler) keybind_prev_handler);
keybinder_unbind("XF86AudioNext", (KeybinderHandler) keybind_next_handler);
keybinder_unbind("XF86AudioMedia", (KeybinderHandler) keybind_media_handler);
#endif
g_option_context_free(cwin->cmd_context);
g_slice_free(struct con_win, cwin);
}
