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 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 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);
}
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;
}
