static void
cddb_thread (void *params_void)
{
struct cddb_thread_params *params = (struct cddb_thread_params *)params_void;
char disc_list[(CDDB_CATEGORY_SIZE + CDDB_DISCID_SIZE + 1) * MAX_CDDB_DISCS];
const int num_discs = resolve_disc(params->disc, disc_list);
if (num_discs <= 0) {
trace("disc not resolved\n");
cleanup_thread_params(params);
return;
}
trace("disc resolved\n");
char num_tracks[4];
int track_count = cddb_disc_get_track_count(params->disc);
snprintf(num_tracks, sizeof(num_tracks), "%02d", track_count);
for (size_t i = 0; params->items[i]; i++) {
deadbeef->pl_add_meta(params->items[i], CDDB_IDS_TAG, disc_list);
write_metadata(params->items[i], params->disc, num_tracks);
}
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, DDB_PLAYLIST_CHANGE_CONTENT, 0);
}
static CdAlbum toAlbum(cddb_disc_t *disc, const CdAlbum &initial=CdAlbum())
{
CdAlbum album;
if (!disc) {
return album;
}
album.name=QString::fromUtf8(cddb_disc_get_title(disc));
album.artist=QString::fromUtf8(cddb_disc_get_artist(disc));
album.genre=QString::fromUtf8(cddb_disc_get_genre(disc));
album.year=cddb_disc_get_year(disc);
int numTracks=cddb_disc_get_track_count(disc);
if (numTracks>0) {
for (int t=0; t<numTracks; ++t) {
cddb_track_t *trk=cddb_disc_get_track(disc, t);
if (!trk) {
continue;
}
Song track;
track.track=cddb_track_get_number(trk);
track.title=QString::fromUtf8(cddb_track_get_title(trk));
track.artist=QString::fromUtf8(cddb_track_get_artist(trk));
track.albumartist=album.artist;
track.album=album.name;
track.id=track.track;
track.file=QString("%1.wav").arg(track.track);
track.year=album.year;
if (initial.isNull()) {
track.time=cddb_track_get_length(trk);
if (CddbInterface::dataTrack()==track.title) {
// Adjust last track length...
if (album.tracks.count()) {
Song last=album.tracks.takeLast();
last.time-=FRAMES_TO_SECONDS(11400);
album.tracks.append(last);
}
} else {
album.tracks.append(track);
}
} else if (t>=initial.tracks.count()) {
break;
} else {
track.time=initial.tracks.at(t).time;
album.tracks.append(track);
}
}
}
// Ensure we always have same number of tracks...
if (!initial.isNull() && album.tracks.count()<initial.tracks.count()) {
for (int i=album.tracks.count(); i<initial.tracks.count(); ++i) {
album.tracks.append(initial.tracks.at(i));
}
}
return album;
}
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;
}
int trackCount() {
return cddb_disc_get_track_count(disc);
}
