static void handle_partofset_field (xmms_xform_t *xform, xmms_id3v2_header_t *head, const gchar *key, gchar *buf, gsize len) { const gchar *enc; gchar *nval; gsize clen; enc = binary_to_enc (buf[0]); nval = convert_id3_text (enc, &buf[1], len - 1, &clen); if (nval) { gint partofset, totalset; parse_number_slash_number (nval, &partofset, &totalset); if (partofset > 0) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_PARTOFSET; xmms_xform_metadata_set_int (xform, metakey, partofset); } if (totalset > 0) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TOTALSET; xmms_xform_metadata_set_int (xform, metakey, totalset); } g_free (nval); } }
/* note that "key" is NOT NUL-terminated here, * but "value" is. */ static void handle_comment (xmms_xform_t *xform, const gchar *key, gint key_len, const gchar *value) { gchar buf[8]; gint i; for (i = 0; i < G_N_ELEMENTS (properties); i++) { if ((!g_ascii_strncasecmp (key, "MUSICBRAINZ_ALBUMARTISTID", key_len)) && (!g_ascii_strcasecmp (value, MUSICBRAINZ_VA_ID))) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_COMPILATION; xmms_xform_metadata_set_int (xform, metakey, 1); } else if (!g_ascii_strncasecmp (key, properties[i].vname, key_len)) { if (properties[i].type == INTEGER) { gint tmp = strtol (value, NULL, 10); xmms_xform_metadata_set_int (xform, properties[i].xname, tmp); } else if (properties[i].type == RPGAIN) { g_snprintf (buf, sizeof (buf), "%f", pow (10.0, g_strtod (value, NULL) / 20)); /** @todo this should probably be a int instead? */ xmms_xform_metadata_set_str (xform, properties[i].xname, buf); } else { xmms_xform_metadata_set_str (xform, properties[i].xname, value); } } } }
static void handle_tracknr_field (xmms_xform_t *xform, xmms_id3v2_header_t *head, const gchar *key, gchar *buf, gsize len) { const gchar *enc; gchar *nval; gsize clen; enc = binary_to_enc (buf[0]); nval = convert_id3_text (enc, &buf[1], len - 1, &clen); if (nval) { gint tracknr, tracktotal; parse_number_slash_number (nval, &tracknr, &tracktotal); if (tracknr > 0) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TRACKNR; xmms_xform_metadata_set_int (xform, metakey, tracknr); } if (tracktotal > 0) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TOTALTRACKS; xmms_xform_metadata_set_int (xform, metakey, tracktotal); } g_free (nval); } }
static void xmms_wave_get_media_info (xmms_xform_t *xform) { xmms_wave_data_t *data; gdouble playtime; guint samples_total, bitrate; gint filesize; const gchar *metakey; g_return_if_fail (xform); data = xmms_xform_private_data_get (xform); g_return_if_fail (data); samples_total = data->bytes_total / (data->bits_per_sample / 8); playtime = (gdouble) samples_total / data->samplerate / data->channels; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; xmms_xform_metadata_set_int (xform, metakey, playtime * 1000); } bitrate = data->bits_per_sample * data->samplerate / data->channels; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, bitrate); }
static void outdata_type_metadata_collect (xmms_xform_t *xform) { gint val; const char *mime; xmms_stream_type_t *type; type = xform->out_type; mime = xmms_stream_type_get_str (type, XMMS_STREAM_TYPE_MIMETYPE); if (strcmp (mime, "audio/pcm") != 0) { return; } val = xmms_stream_type_get_int (type, XMMS_STREAM_TYPE_FMT_FORMAT); if (val != -1) { const gchar *name = xmms_sample_name_get ((xmms_sample_format_t) val); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_SAMPLE_FMT, name); } val = xmms_stream_type_get_int (type, XMMS_STREAM_TYPE_FMT_SAMPLERATE); if (val != -1) { xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_SAMPLERATE, val); } val = xmms_stream_type_get_int (type, XMMS_STREAM_TYPE_FMT_CHANNELS); if (val != -1) { xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_CHANNELS, val); } }
static void xmms_mpc_cache_streaminfo (xmms_xform_t *xform) { xmms_mpc_data_t *data; gint bitrate, duration, filesize; gchar buf[8]; const gchar *metakey; g_return_if_fail (xform); data = xmms_xform_private_data_get (xform); g_return_if_fail (data); XMMS_DBG ("stream version = %d", data->info.stream_version); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) { duration = mpc_streaminfo_get_length (&data->info) * 1000; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; xmms_xform_metadata_set_int (xform, metakey, duration); } bitrate = (data->info.bitrate) ? data->info.bitrate : data->info.average_bitrate; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, bitrate); if (data->info.gain_album) { g_snprintf (buf, sizeof (buf), "%f", xmms_mpc_normalize_gain ((gdouble) data->info.gain_album)); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_GAIN_ALBUM; xmms_xform_metadata_set_str (xform, metakey, buf); } if (data->info.gain_title) { g_snprintf (buf, sizeof (buf), "%f", xmms_mpc_normalize_gain ((gdouble) data->info.gain_title)); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_GAIN_TRACK; xmms_xform_metadata_set_str (xform, metakey, buf); } if (data->info.peak_album) { g_snprintf (buf, sizeof (buf), "%f", xmms_mpc_normalize_peak ((gdouble) data->info.peak_album)); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_PEAK_ALBUM; xmms_xform_metadata_set_str (xform, metakey, buf); } if (data->info.peak_title) { g_snprintf (buf, sizeof (buf), "%f", xmms_mpc_normalize_peak ((gdouble) data->info.peak_title)); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_PEAK_TRACK; xmms_xform_metadata_set_str (xform, metakey, buf); } }
/* * Member functions */ static gboolean xmms_samba_init (xmms_xform_t *xform) { xmms_samba_data_t *data; const gchar *url; const gchar *metakey; struct stat st; gint fd, err; g_return_val_if_fail (xform, FALSE); url = xmms_xform_indata_get_str (xform, XMMS_STREAM_TYPE_URL); g_return_val_if_fail (url, FALSE); G_LOCK (mutex); err = smbc_stat (url, &st); G_UNLOCK (mutex); if (err < 0) { xmms_log_error ("%s", strerror (errno)); return FALSE; } if (!S_ISREG (st.st_mode)) { xmms_log_error ("%s is not a regular file.", url); return FALSE; } G_LOCK (mutex); fd = smbc_open (url, O_RDONLY | O_NONBLOCK, 0); G_UNLOCK (mutex); if (fd == -1) { xmms_log_error ("%s", strerror (errno)); return FALSE; } data = g_new0 (xmms_samba_data_t, 1); data->fd = fd; xmms_xform_private_data_set (xform, data); xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "application/octet-stream", XMMS_STREAM_TYPE_END); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; xmms_xform_metadata_set_int (xform, metakey, st.st_size); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_LMOD; xmms_xform_metadata_set_int (xform, metakey, st.st_mtime); return TRUE; }
static gboolean xmms_asf_handle_tag_old_tracknr (xmms_xform_t *xform, const gchar *key, const gchar *value, gsize length) { gint ivalue; /* WM/TrackNumber overrides WM/Track value as specified in the Microsoft * documentation at http://msdn2.microsoft.com/en-us/library/aa392014.aspx * so lets check if something else has set the tracknr property before us. */ if (xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TRACKNR, &ivalue)) { return FALSE; } /* Ok, nothing set, lets handle "WM/Track" as "WM/TrackNumber" */ if (!xmms_xform_metadata_mapper_match (xform, "WM/TrackNumber", value, length)) { return FALSE; } /* Last quirk, WM/Track is 0-indexed, need to fix that */ xmms_xform_metadata_get_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TRACKNR, &ivalue); xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TRACKNR, ivalue + 1); return TRUE; }
/** * @todo Enable option to use STIL for media info and * timedatabase for song length. */ static void xmms_sid_get_media_info (xmms_xform_t *xform) { xmms_sid_data_t *data; const gchar *md5sum; const gchar *metakey; char artist[32]; char title[32]; gint err; data = xmms_xform_private_data_get (xform); g_return_if_fail (data); err = sidplay_wrapper_songinfo (data->wrapper, artist, title); if (err > 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TITLE; xmms_xform_metadata_set_str (xform, metakey, title); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ARTIST; xmms_xform_metadata_set_str (xform, metakey, artist); } metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SUBTUNES; xmms_xform_metadata_set_int (xform, metakey, sidplay_wrapper_subtunes (data->wrapper)); md5sum = sidplay_wrapper_md5 (data->wrapper); xmms_xform_metadata_set_str (xform, "HVSCfingerprint", md5sum); xmms_sid_get_songlength (xform); }
static void xmms_speex_read_metadata (xmms_xform_t *xform, xmms_speex_data_t *data) { xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE, data->speexheader->bitrate); }
static void xmms_mp4_get_mediainfo (xmms_xform_t *xform) { xmms_mp4_data_t *data; const gchar *metakey; glong temp; gint i, num_items; g_return_if_fail (xform); data = xmms_xform_private_data_get (xform); g_return_if_fail (data); if ((temp = mp4ff_get_sample_rate (data->mp4ff, data->track)) > 0) { glong srate = temp; if ((temp = mp4ff_get_track_duration (data->mp4ff, data->track)) >= 0) { glong msec = ((gint64) temp) * 1000 / srate; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION, xmms_xform_metadata_set_int (xform, metakey, msec); } } if ((temp = mp4ff_get_avg_bitrate (data->mp4ff, data->track)) >= 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, temp); } num_items = mp4ff_meta_get_num_items (data->mp4ff); for (i = 0; i < num_items; i++) { gchar *key, *value; guint length; length = mp4ff_meta_get_by_index (data->mp4ff, i, &key, &value); if (length > 0) { if (!xmms_xform_metadata_mapper_match (xform, key, value, length)) { /* iTunSMPB should be handled in xmms_mp4_gapless_try */ if (0 != g_ascii_strcasecmp (key, "iTunSMPB")) { XMMS_DBG ("Unhandled tag '%s' = '%s'", key, value); } } g_free (key); g_free (value); } } }
static gboolean xmms_apetag_handle_tag_track (xmms_xform_t *xform, const gchar *key, const gchar *value, gsize length) { gint tracknr, tracktotal; xmms_apetag_parse_number_slash_number (value, &tracknr, &tracktotal); if (tracknr > 0) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TRACKNR; xmms_xform_metadata_set_int (xform, metakey, tracknr); } if (tracktotal > 0) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TOTALTRACKS; xmms_xform_metadata_set_int (xform, metakey, tracktotal); } return tracknr > 0; }
static gboolean xmms_apetag_handle_tag_disc (xmms_xform_t *xform, const gchar *key, const gchar *value, gsize length) { gint partofset, totalset; xmms_apetag_parse_number_slash_number (value, &partofset, &totalset); if (partofset > 0) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_PARTOFSET; xmms_xform_metadata_set_int (xform, metakey, partofset); } if (totalset > 0) { const gchar *metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TOTALSET; xmms_xform_metadata_set_int (xform, metakey, totalset); } return partofset > 0; }
static gboolean xmms_asf_handle_tag_is_vbr (xmms_xform_t *xform, const gchar *key, const gchar *value, gsize length) { if (strcasecmp ("true", value) == 0) { xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_IS_VBR, 1); return TRUE; } return FALSE; }
gboolean xmms_xform_metadata_parse_compilation (xmms_xform_t *xform, const gchar *key, const gchar *value, gsize length) { const gchar *musicbrainz_va_id = "89ad4ac3-39f7-470e-963a-56509c546377"; gchar *endptr = NULL; gint number; if (strcasecmp (musicbrainz_va_id, value) == 0) { return xmms_xform_metadata_set_int (xform, key, 1); } number = strtol (value, &endptr, 10); if (endptr > value && *endptr == '\0' && number > 0) { return xmms_xform_metadata_set_int (xform, key, 1); } return FALSE; }
static gboolean xmms_id3v2_init (xmms_xform_t *xform) { xmms_id3v2_data_t *data; xmms_id3v2_header_t head; xmms_error_t err; guchar hbuf[20]; gint filesize; guchar *buf; gint res; const gchar *metakey; xmms_error_reset (&err); if (xmms_xform_read (xform, hbuf, 10, &err) != 10) { XMMS_DBG ("Couldn't read id3v2 header..."); return FALSE; } data = g_new0 (xmms_id3v2_data_t, 1); xmms_xform_private_data_set (xform, data); if (!xmms_id3v2_is_header (hbuf, &head)) { XMMS_DBG ("Couldn't parse id3v2 header!?"); return FALSE; } /* Total data length is the length of header data plus header bytes */ data->len = head.len + 10; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; xmms_xform_metadata_set_int (xform, metakey, filesize - head.len); } buf = g_malloc (head.len); res = xmms_xform_read (xform, buf, head.len, &err); if (res != head.len) { XMMS_DBG ("Couldn't read id3v2 %d bytes of id3-data data (%d)", head.len, res); return FALSE; } xmms_id3v2_parse (xform, buf, &head); g_free (buf); xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "application/octet-stream", XMMS_STREAM_TYPE_END); return TRUE; }
static void handle_id3v2_txxx (xmms_xform_t *xform, xmms_id3v2_header_t *head, const gchar *_key, gchar *buf, gsize len) { const gchar *enc; gchar *cbuf; const gchar *key, *val; const gchar *metakey; gsize clen; enc = binary_to_enc (buf[0]); cbuf = convert_id3_text (enc, &buf[1], len - 1, &clen); if (!cbuf) return; key = cbuf; val = find_nul (cbuf, &clen); if (!val) { g_free (cbuf); return; } if (g_ascii_strcasecmp (key, "MusicBrainz Album Id") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM_ID; xmms_xform_metadata_set_str (xform, metakey, val); } else if (g_ascii_strcasecmp (key, "MusicBrainz Artist Id") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ARTIST_ID; xmms_xform_metadata_set_str (xform, metakey, val); } else if ((g_ascii_strcasecmp (key, "MusicBrainz Album Artist Id") == 0) && (g_ascii_strcasecmp (val, MUSICBRAINZ_VA_ID) == 0)) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_COMPILATION; xmms_xform_metadata_set_int (xform, metakey, 1); } else if (g_ascii_strcasecmp (key, "ASIN") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ASIN; xmms_xform_metadata_set_str (xform, metakey, val); } else if (g_ascii_strcasecmp (key, "QuodLibet::albumartist") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM_ARTIST; xmms_xform_metadata_set_str (xform, metakey, val); } else if (g_ascii_strcasecmp (key, "ALBUMARTISTSORT") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM_ARTIST_SORT; xmms_xform_metadata_set_str (xform, metakey, val); } else if (g_ascii_strcasecmp (key, "BARCODE") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BARCODE; xmms_xform_metadata_set_str (xform, metakey, val); } else if (g_ascii_strcasecmp (key, "CATALOGNUMBER") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_CATALOGNUMBER; xmms_xform_metadata_set_str (xform, metakey, val); } else { XMMS_DBG ("Unhandled tag 'TXXX:%s' = '%s'", key, val); } g_free (cbuf); }
gboolean xmms_xform_metadata_parse_number (xmms_xform_t *xform, const gchar *key, const gchar *value, gsize length) { gchar *endptr = NULL; gint number; number = strtol (value, &endptr, 10); if (endptr > value && *endptr == '\0') { xmms_xform_metadata_set_int (xform, key, number); return TRUE; } return FALSE; }
static void handle_id3v2_txxx (xmms_xform_t *xform, xmms_id3v2_header_t *head, const gchar *_key, gchar *buf, gsize len) { const gchar *enc; gchar *cbuf; const gchar *key, *val; const gchar *metakey; gsize clen; enc = binary_to_enc (buf[0]); cbuf = convert_id3_text (enc, &buf[1], len - 1, &clen); if (!cbuf) return; key = cbuf; val = find_nul (cbuf, &clen); if (!val) { g_free (cbuf); return; } if (g_ascii_strcasecmp (key, "MusicBrainz Album Id") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM_ID; xmms_xform_metadata_set_str (xform, metakey, val); } else if (g_ascii_strcasecmp (key, "MusicBrainz Artist Id") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ARTIST_ID; xmms_xform_metadata_set_str (xform, metakey, val); } else if ((g_ascii_strcasecmp (key, "MusicBrainz Album Artist Id") == 0) && (g_ascii_strcasecmp (val, MUSICBRAINZ_VA_ID) == 0)) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_COMPILATION; xmms_xform_metadata_set_int (xform, metakey, 1); } else if (g_ascii_strcasecmp (key, "ASIN") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ASIN; xmms_xform_metadata_set_str (xform, metakey, val); } else if (g_ascii_strcasecmp (key, "QuodLibet::albumartist") == 0) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM_ARTIST; xmms_xform_metadata_set_str (xform, metakey, val); // ArtistAlbumSort as last resort } else if ((g_ascii_strcasecmp (key, "ALBUMARTISTSORT") == 0)) { const gchar *tmp; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM_ARTIST; if (xmms_xform_metadata_get_str (xform, metakey, &tmp) && !strlen (tmp)) { xmms_xform_metadata_set_str (xform, metakey, val); } } g_free (cbuf); }
static void xmms_faad_get_mediainfo (xmms_xform_t *xform) { xmms_faad_data_t *data; const gchar *metakey; g_return_if_fail (xform); data = xmms_xform_private_data_get (xform); g_return_if_fail (data); if (data->filetype == FAAD_TYPE_ADIF) { guint skip_size, bitrate; gint32 duration; skip_size = (data->buffer[4] & 0x80) ? 9 : 0; bitrate = ((guint) (data->buffer[4 + skip_size] & 0x0F) << 19) | ((guint) data->buffer[5 + skip_size] << 11) | ((guint) data->buffer[6 + skip_size] << 3) | ((guint) data->buffer[7 + skip_size] & 0xE0); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, bitrate); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; if (xmms_xform_metadata_get_int (xform, metakey, &duration)) { duration = ((float) duration * 8000.f) / ((float) bitrate) + 0.5f; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; xmms_xform_metadata_set_int (xform, metakey, duration); } } else if (data->filetype == FAAD_TYPE_ADTS) { gint32 val = faad_mpeg_samplerates[(data->buffer[2] & 0x3c) >> 2]; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SAMPLERATE; xmms_xform_metadata_set_int (xform, metakey, val); }
static void handle_int_field (xmms_xform_t *xform, xmms_id3v2_header_t *head, const gchar *key, gchar *buf, gsize len) { gchar *nval; const gchar *tmp; gint i; tmp = binary_to_enc (buf[0]); nval = convert_id3_text (tmp, &buf[1], len - 1, NULL); if (nval) { i = strtol (nval, NULL, 10); xmms_xform_metadata_set_int (xform, key, i); g_free (nval); } }
static void xmms_mpc_collect_metadata (xmms_xform_t *xform) { xmms_mpc_data_t *data; xmms_apetag_t *tag; gint i, intval; const gchar *strval; g_return_if_fail (xform); data = xmms_xform_private_data_get (xform); g_return_if_fail (data); tag = xmms_apetag_init (xform); if (xmms_apetag_read (tag)) { for (i = 0; i < G_N_ELEMENTS (properties); i++) { switch (properties[i].type) { case INTEGER: intval = xmms_apetag_lookup_int (tag, properties[i].vname); if (intval > 0) { xmms_xform_metadata_set_int (xform, properties[i].xname, intval); } break; case STRING: strval = xmms_apetag_lookup_str (tag, properties[i].vname); if (strval != NULL) { xmms_xform_metadata_set_str (xform, properties[i].xname, strval); } break; } } } xmms_apetag_destroy (tag); }
static gboolean xmms_cdda_init (xmms_xform_t *xform) { CdIo_t *cdio = NULL; cdrom_drive_t *drive = NULL; const gchar *url; gchar **url_data = NULL; gchar *url_end; xmms_cdda_data_t *data; guint playtime; lsn_t first_lsn; track_t track; gchar *disc_id = NULL; gchar *cddb_id = NULL; xmms_config_property_t *val; const gchar *device; const gchar *metakey; gboolean ret = TRUE; g_return_val_if_fail (xform, FALSE); url = xmms_xform_indata_get_str (xform, XMMS_STREAM_TYPE_URL); if (g_ascii_strcasecmp (url, "cdda://") == 0) { xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "application/x-xmms2-playlist-entries", XMMS_STREAM_TYPE_END); return TRUE; } val = xmms_xform_config_lookup (xform, "device"); device = xmms_config_property_get_string (val); if (!get_disc_ids (device, &disc_id, &cddb_id, 0)) { return FALSE; } url += 7; url_data = g_strsplit (url, "/", 2); if (g_ascii_strcasecmp (url_data[0], disc_id)) { xmms_log_error ("Wrong disc inserted."); ret = FALSE; goto end; } if (url_data[1] == NULL) { xmms_log_error ("Missing track number."); ret = FALSE; goto end; } track = strtol (url_data[1], &url_end, 10); if (url_data[1] == url_end) { xmms_log_error ("Invalid track, need a number."); ret = FALSE; goto end; } cdio = open_cd (xform); if (!cdio) { ret = FALSE; goto end; } drive = cdio_cddap_identify_cdio (cdio, 1, NULL); if (!drive) { xmms_log_error ("Failed to identify drive."); ret = FALSE; goto end; } if (cdio_cddap_open (drive)) { xmms_log_error ("Unable to open disc."); ret = FALSE; goto end; } first_lsn = cdio_cddap_track_firstsector (drive, track); if (first_lsn == -1) { xmms_log_error ("No such track."); ret = FALSE; goto end; } data = g_new (xmms_cdda_data_t, 1); data->cdio = cdio; data->drive = drive; data->track = track; data->first_lsn = first_lsn; data->last_lsn = cdio_cddap_track_lastsector (drive, data->track); data->current_lsn = first_lsn; data->buf_used = CDIO_CD_FRAMESIZE_RAW; playtime = (data->last_lsn - data->first_lsn) * 1000.0 / CDIO_CD_FRAMES_PER_SEC; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; xmms_xform_metadata_set_int (xform, metakey, playtime); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, 141120); xmms_xform_metadata_set_str (xform, "disc_id", url_data[0]); xmms_xform_metadata_set_str (xform, "cddb_id", cddb_id); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_TRACKNR; xmms_xform_metadata_set_int (xform, metakey, track); xmms_xform_private_data_set (xform, data); xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "audio/pcm", XMMS_STREAM_TYPE_FMT_FORMAT, XMMS_SAMPLE_FORMAT_S16, XMMS_STREAM_TYPE_FMT_CHANNELS, 2, XMMS_STREAM_TYPE_FMT_SAMPLERATE, 44100, XMMS_STREAM_TYPE_END); end: /* These are to be destroyed in every cases... */ g_free (cddb_id); g_free (disc_id); g_strfreev (url_data); /* destroy cdio/drive in case of failure */ if (!ret) { if (drive) { cdio_cddap_close_no_free_cdio (drive); } if (cdio) { cdio_destroy (cdio); } } return ret; }
static gboolean xmms_mad_init (xmms_xform_t *xform) { struct mad_frame frame; struct mad_stream stream; xmms_error_t err; guchar buf[40960]; xmms_mad_data_t *data; int len; const gchar *metakey; g_return_val_if_fail (xform, FALSE); data = g_new0 (xmms_mad_data_t, 1); mad_stream_init (&data->stream); mad_frame_init (&data->frame); mad_synth_init (&data->synth); xmms_xform_private_data_set (xform, data); data->buffer_length = 0; data->synthpos = 0x7fffffff; mad_stream_init (&stream); mad_frame_init (&frame); len = xmms_xform_peek (xform, buf, 40960, &err); mad_stream_buffer (&stream, buf, len); while (mad_frame_decode (&frame, &stream) == -1) { if (!MAD_RECOVERABLE (stream.error)) { XMMS_DBG ("couldn't decode %02x %02x %02x %02x",buf[0],buf[1],buf[2],buf[3]); mad_frame_finish (&frame); mad_stream_finish (&stream); return FALSE; } } data->channels = frame.header.mode == MAD_MODE_SINGLE_CHANNEL ? 1 : 2; data->samplerate = frame.header.samplerate; if (frame.header.flags & MAD_FLAG_PROTECTION) { XMMS_DBG ("Frame has protection enabled"); if (stream.anc_ptr.byte > stream.buffer + 2) { stream.anc_ptr.byte = stream.anc_ptr.byte - 2; } } data->samples_to_play = -1; data->xing = xmms_xing_parse (stream.anc_ptr); if (data->xing) { xmms_xing_lame_t *lame; XMMS_DBG ("File with Xing header!"); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_IS_VBR; xmms_xform_metadata_set_int (xform, metakey, 1); if (xmms_xing_has_flag (data->xing, XMMS_XING_FRAMES)) { guint duration; mad_timer_t timer; timer = frame.header.duration; mad_timer_multiply (&timer, xmms_xing_get_frames (data->xing)); duration = mad_timer_count (timer, MAD_UNITS_MILLISECONDS); XMMS_DBG ("XING duration %d", duration); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; xmms_xform_metadata_set_int (xform, metakey, duration); if (xmms_xing_has_flag (data->xing, XMMS_XING_BYTES) && duration) { guint tmp; tmp = xmms_xing_get_bytes (data->xing) * ((guint64)8000) / duration; XMMS_DBG ("XING bitrate %d", tmp); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, tmp); } } lame = xmms_xing_get_lame (data->xing); if (lame) { /* FIXME: add a check for ignore_lame_headers from the medialib */ data->frames_to_skip = 1; data->samples_to_skip = lame->start_delay; data->samples_to_play = ((guint64) xmms_xing_get_frames (data->xing) * 1152ULL) - lame->start_delay - lame->end_padding; XMMS_DBG ("Samples to skip in the beginning: %d, total: %" G_GINT64_FORMAT, data->samples_to_skip, data->samples_to_play); /* metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_GAIN_ALBUM; xmms_xform_metadata_set_int (xform, metakey, lame->audiophile_gain); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_PEAK_TRACK; xmms_xform_metadata_set_int (xform, metakey, lame->peak_amplitude); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_GAIN_TRACK; xmms_xform_metadata_set_int (xform, metakey, lame->radio_gain); */ } } else { gint filesize; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, frame.header.bitrate); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; if (!xmms_xform_metadata_get_int (xform, metakey, &filesize)) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) { gint32 val; val = (gint32) (filesize * (gdouble) 8000.0 / frame.header.bitrate); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; xmms_xform_metadata_set_int (xform, metakey, val); } } } /* seeking needs bitrate */ data->bitrate = frame.header.bitrate; if (xmms_id3v1_get_tags (xform) < 0) { mad_stream_finish (&data->stream); mad_frame_finish (&data->frame); mad_synth_finish (&data->synth); if (data->xing) { xmms_xing_free (data->xing); } return FALSE; } xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "audio/pcm", XMMS_STREAM_TYPE_FMT_FORMAT, XMMS_SAMPLE_FORMAT_S16, XMMS_STREAM_TYPE_FMT_CHANNELS, data->channels, XMMS_STREAM_TYPE_FMT_SAMPLERATE, data->samplerate, XMMS_STREAM_TYPE_END); mad_frame_finish (&frame); mad_stream_finish (&stream); return TRUE; }
static void xmms_vorbis_set_duration (xmms_xform_t *xform, guint dur) { xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION, dur * 1000); }
static gboolean xmms_gvfs_init (xmms_xform_t *xform) { xmms_gvfs_data_t *data; GFile *file; GFileInfo *info; GFileInputStream *handle; GError *error = NULL; const gchar *url; url = xmms_xform_indata_get_str (xform, XMMS_STREAM_TYPE_URL); g_return_val_if_fail (url, FALSE); /* This is an ugly hack to handle files with chars needing url encoding */ if (!g_ascii_strncasecmp (url, "file://", 7)) { file = g_file_new_for_path (url+7); } else { file = g_file_new_for_uri (url); } handle = g_file_read (file, NULL, &error); g_object_unref (file); if (!handle) { xmms_log_error ("Failed to upen url %s for reading: %s", url, error->message); return FALSE; } data = g_new (xmms_gvfs_data_t, 1); data->handle = G_INPUT_STREAM (handle); xmms_xform_private_data_set (xform, data); info = g_file_input_stream_query_info (handle, (char *)query_attributes, NULL, &error); if (!info) { xmms_log_info ("failed to query information for %s", url); } else { int i; for (i = 0; i < G_N_ELEMENTS (attr_map); i++) { if (!g_file_info_has_attribute (info, attr_map[i].gvfs)) { continue; } switch (attr_map[i].type) { case XMMSV_TYPE_STRING: { gchar *attr = g_file_info_get_attribute_as_string (info, attr_map[i].gvfs); xmms_xform_metadata_set_str (xform, attr_map[i].mlib, attr); g_free (attr); break; } case XMMSV_TYPE_INT32: { /* right now the xform metadata api only handles strings * and 32 bit ints. however the gvfs api returns uint64 for * the numeric attributes we're interested in and we just * pass that to the xform and pray that it doesn't overflow * as we know it's unsafe. */ gint64 attr = g_file_info_get_attribute_uint64 (info, attr_map[i].gvfs); xmms_xform_metadata_set_int (xform, attr_map[i].mlib, attr); break; } default: g_assert_not_reached (); } } g_object_unref (info); } xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "application/octet-stream", XMMS_STREAM_TYPE_END); return TRUE; }
static gboolean xmms_flac_init (xmms_xform_t *xform) { xmms_flac_data_t *data; xmms_sample_format_t sample_fmt; FLAC__bool retval; #if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7 FLAC__StreamDecoderState init_status; #else FLAC__StreamDecoderInitStatus init_status; #endif gint filesize; const gchar *metakey; g_return_val_if_fail (xform, FALSE); data = g_new0 (xmms_flac_data_t, 1); xmms_xform_private_data_set (xform, data); data->flacdecoder = FLAC__stream_decoder_new (); /* we don't need to explicitly tell the decoder to respond to * FLAC__METADATA_TYPE_STREAMINFO here, it always does. */ #if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7 FLAC__seekable_stream_decoder_set_metadata_respond (data->flacdecoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); FLAC__seekable_stream_decoder_set_eof_callback (data->flacdecoder, flac_callback_eof); FLAC__seekable_stream_decoder_set_read_callback (data->flacdecoder, flac_callback_read); FLAC__seekable_stream_decoder_set_seek_callback (data->flacdecoder, flac_callback_seek); FLAC__seekable_stream_decoder_set_tell_callback (data->flacdecoder, flac_callback_tell); FLAC__seekable_stream_decoder_set_write_callback (data->flacdecoder, flac_callback_write); FLAC__seekable_stream_decoder_set_error_callback (data->flacdecoder, flac_callback_error); FLAC__seekable_stream_decoder_set_length_callback (data->flacdecoder, flac_callback_length); FLAC__seekable_stream_decoder_set_metadata_callback (data->flacdecoder, flac_callback_metadata); FLAC__seekable_stream_decoder_set_client_data (data->flacdecoder, xform); init_status = FLAC__seekable_stream_decoder_init (data->flacdecoder); if (init_status != FLAC__SEEKABLE_STREAM_DECODER_OK) { const gchar *errmsg = FLAC__seekable_stream_decoder_get_resolved_state_string (data->flacdecoder); XMMS_DBG ("FLAC init failed: %s", errmsg); goto err; } #else FLAC__stream_decoder_set_metadata_respond (data->flacdecoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); FLAC__stream_decoder_set_metadata_respond (data->flacdecoder, FLAC__METADATA_TYPE_PICTURE); init_status = FLAC__stream_decoder_init_stream (data->flacdecoder, flac_callback_read, flac_callback_seek, flac_callback_tell, flac_callback_length, flac_callback_eof, flac_callback_write, flac_callback_metadata, flac_callback_error, xform); if (init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) { XMMS_DBG ("FLAC init failed: %s", FLAC__stream_decoder_get_resolved_state_string (data->flacdecoder)); goto err; } #endif retval = FLAC__stream_decoder_process_until_end_of_metadata (data->flacdecoder); if (!retval) goto err; if (data->vorbiscomment) { handle_comments (xform, data); } metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, (gint) data->bit_rate); metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) { gint32 val = (gint32) data->total_samples / data->sample_rate * 1000; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; xmms_xform_metadata_set_int (xform, metakey, val); } if (data->bits_per_sample == 8) { sample_fmt = XMMS_SAMPLE_FORMAT_S8; } else if (data->bits_per_sample == 16) { sample_fmt = XMMS_SAMPLE_FORMAT_S16; } else if (data->bits_per_sample == 24) { sample_fmt = XMMS_SAMPLE_FORMAT_S32; } else if (data->bits_per_sample == 32) { sample_fmt = XMMS_SAMPLE_FORMAT_S32; } else { goto err; } xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "audio/pcm", XMMS_STREAM_TYPE_FMT_FORMAT, sample_fmt, XMMS_STREAM_TYPE_FMT_CHANNELS, data->channels, XMMS_STREAM_TYPE_FMT_SAMPLERATE, data->sample_rate, XMMS_STREAM_TYPE_END); data->buffer = g_string_new (NULL); return TRUE; err: FLAC__stream_decoder_finish (data->flacdecoder); FLAC__stream_decoder_delete (data->flacdecoder); g_free (data); xmms_xform_private_data_set (xform, NULL); return FALSE; }
static void xmms_sndfile_get_media_info (xmms_xform_t *xform) { xmms_sndfile_data_t *data; gdouble playtime; guint bitrate; gint filesize = 0, bps = -1; const gchar *metakey, *str; g_return_if_fail (xform); data = xmms_xform_private_data_get (xform); g_return_if_fail (data); playtime = (gdouble) data->sf_info.frames / data->sf_info.samplerate; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) { metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION; xmms_xform_metadata_set_int (xform, metakey, playtime * 1000); } switch (data->sf_info.format) { case SF_FORMAT_PCM_S8: bps = 8; break; case SF_FORMAT_PCM_16: bps = 16; break; case SF_FORMAT_PCM_24: bps = 24; break; case SF_FORMAT_PCM_32: bps = 32; break; case SF_FORMAT_PCM_U8: bps = 8; break; case SF_FORMAT_FLOAT: bps = 32; break; case SF_FORMAT_DOUBLE: bps = 64; break; case SF_FORMAT_ULAW: case SF_FORMAT_ALAW: case SF_FORMAT_IMA_ADPCM: case SF_FORMAT_MS_ADPCM: case SF_FORMAT_GSM610: case SF_FORMAT_VOX_ADPCM: case SF_FORMAT_G721_32: case SF_FORMAT_G723_24: case SF_FORMAT_G723_40: case SF_FORMAT_DWVW_12: case SF_FORMAT_DWVW_16: case SF_FORMAT_DWVW_24: case SF_FORMAT_DWVW_N: case SF_FORMAT_DPCM_8: case SF_FORMAT_DPCM_16: case SF_FORMAT_VORBIS: default: break; } if (bps >= 0) { bitrate = bps * data->sf_info.samplerate / data->sf_info.channels; } else { /* Approximate bitrate for compressed formats from the total file * length and sample rate. */ bitrate = filesize / (data->sf_info.frames / data->sf_info.samplerate); } metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE; xmms_xform_metadata_set_int (xform, metakey, bitrate); SF2XMMS_META_TRANSCODE (str, data->sndfile, xform, SF_STR_ARTIST, XMMS_MEDIALIB_ENTRY_PROPERTY_ARTIST); SF2XMMS_META_TRANSCODE (str, data->sndfile, xform, SF_STR_ALBUM, XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM); SF2XMMS_META_TRANSCODE (str, data->sndfile, xform, SF_STR_COMMENT, XMMS_MEDIALIB_ENTRY_PROPERTY_COMMENT); SF2XMMS_META_TRANSCODE (str, data->sndfile, xform, SF_STR_COPYRIGHT, XMMS_MEDIALIB_ENTRY_PROPERTY_COPYRIGHT); SF2XMMS_META_TRANSCODE (str, data->sndfile, xform, SF_STR_DATE, XMMS_MEDIALIB_ENTRY_PROPERTY_YEAR); /* Verify! */ /* SF2XMMS_META_TRANSCODE (str, data->sndfile, xform, SF_STR_LICENSE, XMMS_MEDIALIB_ENTRY_PROPERTY_???); */ /* SF2XMMS_META_TRANSCODE (str, data->sndfile, xform, SF_STR_SOFTWARE, XMMS_MEDIALIB_ENTRY_PROPERTY_???); */ SF2XMMS_META_TRANSCODE (str, data->sndfile, xform, SF_STR_TITLE, XMMS_MEDIALIB_ENTRY_PROPERTY_TITLE); /* We could fetch ID3 tags here as soon as libsndfile will support this - * Erik of libsndfile has to provide the generic chunk handling though. */ }
static gboolean xmms_gme_init (xmms_xform_t *xform) { xmms_gme_data_t *data; gme_err_t init_error; GString *file_contents; /* The raw data from the file. */ gme_info_t *metadata = NULL; xmms_config_property_t *val; int loops; int maxlength; const char *subtune_str; int subtune = 0; long fadelen = -1; int samplerate; double stereodepth; g_return_val_if_fail (xform, FALSE); data = g_new0 (xmms_gme_data_t, 1); xmms_xform_private_data_set (xform, data); val = xmms_xform_config_lookup (xform, "samplerate"); samplerate = xmms_config_property_get_int (val); if (samplerate < 1) samplerate = GME_DEFAULT_SAMPLE_RATE; data->samplerate = samplerate; xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "audio/pcm", /* PCM samples */ XMMS_STREAM_TYPE_FMT_FORMAT, XMMS_SAMPLE_FORMAT_S16, /* 16-bit signed */ XMMS_STREAM_TYPE_FMT_CHANNELS, 2, /* stereo */ XMMS_STREAM_TYPE_FMT_SAMPLERATE, samplerate, XMMS_STREAM_TYPE_END); file_contents = g_string_new (""); for (;;) { xmms_error_t error; gchar buf[4096]; gint ret; ret = xmms_xform_read (xform, buf, sizeof (buf), &error); if (ret == -1) { XMMS_DBG ("Error reading emulated music data"); return FALSE; } if (ret == 0) { break; } g_string_append_len (file_contents, buf, ret); } init_error = gme_open_data (file_contents->str, file_contents->len, &data->emu, samplerate); g_string_free (file_contents, TRUE); if (init_error) { XMMS_DBG ("gme_open_data returned an error: %s", init_error); return FALSE; } if (xmms_xform_metadata_get_str (xform, "subtune", &subtune_str)) { subtune = strtol (subtune_str, NULL, 10); XMMS_DBG ("Setting subtune to %d", subtune); if ((subtune < 0 || subtune > gme_track_count (data->emu))) { XMMS_DBG ("Invalid subtune index"); return FALSE; } } else { xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_SUBTUNES, gme_track_count (data->emu)); } /* * Get metadata here */ init_error = gme_track_info (data->emu, &metadata, subtune); if (init_error) { XMMS_DBG ("Couldn't get GME track info: %s", init_error); init_error = ""; } else { xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TITLE, metadata->song); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_ARTIST, metadata->author); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM, metadata->game); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_COMMENT, metadata->comment); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_YEAR, metadata->copyright); xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_GENRE, metadata->system); /* I mapped genre to the system type */ val = xmms_xform_config_lookup (xform, "loops"); loops = xmms_config_property_get_int (val); XMMS_DBG ("intro_length = %d, loops = %d, loop_length = %d", metadata->intro_length, loops, metadata->loop_length); if (metadata->intro_length > 0) { if ((loops > 0) && (metadata->loop_length > 0)) { fadelen = metadata->intro_length + loops * metadata->loop_length; XMMS_DBG ("fadelen now = %ld", fadelen); } else { fadelen = metadata->length; XMMS_DBG ("fadelen now = %ld", fadelen); } } } val = xmms_xform_config_lookup (xform, "maxlength"); maxlength = xmms_config_property_get_int (val); XMMS_DBG ("maxlength = %d seconds", maxlength); if (maxlength > 0 && (fadelen < 0 || (maxlength * 1000L < fadelen))) { fadelen = maxlength * 1000L; XMMS_DBG ("fadelen now = %ld", fadelen); } XMMS_DBG ("gme.fadelen = %ld", fadelen); val = xmms_xform_config_lookup (xform, "stereodepth"); stereodepth = xmms_config_property_get_float (val); if (stereodepth >= 0.0 && stereodepth <= 1.0) { XMMS_DBG ("Setting stereo depth to %f.", stereodepth); gme_set_stereo_depth (data->emu, stereodepth); } else { XMMS_DBG ("gme.stereodepth = %f out of range 0.0 - 1.0; not setting.", stereodepth); } init_error = gme_start_track (data->emu, subtune); if (init_error) { XMMS_DBG ("gme_start_track returned an error: %s", init_error); gme_free_info (metadata); return FALSE; } if (fadelen > 0) { XMMS_DBG ("Setting song length and fade length..."); xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION, fadelen); gme_set_fade (data->emu, fadelen); } gme_free_info (metadata); return TRUE; }
static gboolean xmms_daap_init (xmms_xform_t *xform) { gint dbid; GSList *dbid_list = NULL; xmms_daap_data_t *data; xmms_daap_login_data_t *login_data; xmms_error_t err; const gchar *url; const gchar *metakey; gchar *command, *hash; guint filesize; g_return_val_if_fail (xform, FALSE); url = xmms_xform_indata_get_str (xform, XMMS_STREAM_TYPE_URL); g_return_val_if_fail (url, FALSE); data = g_new0 (xmms_daap_data_t, 1); xmms_error_reset (&err); if (!get_data_from_url (url, &(data->host), &(data->port), &command, &err)) { goto init_error; } hash = g_strdup_printf ("%s:%u", data->host, data->port); login_data = g_hash_table_lookup (login_sessions, hash); if (!login_data) { XMMS_DBG ("creating login data for %s", hash); login_data = g_new0 (xmms_daap_login_data_t, 1); login_data->request_id = 1; login_data->logged_in = TRUE; login_data->session_id = daap_command_login (data->host, data->port, login_data->request_id, &err); if (xmms_error_iserror (&err)) { g_free (login_data); goto init_error; } g_hash_table_insert (login_sessions, hash, login_data); } login_data->revision_id = daap_command_update (data->host, data->port, login_data->session_id, login_data->request_id); dbid_list = daap_command_db_list (data->host, data->port, login_data->session_id, login_data->revision_id, login_data->request_id); if (!dbid_list) { goto init_error; } /* XXX: see XXX in the browse function above */ dbid = ((cc_item_record_t *) dbid_list->data)->dbid; /* want to request a stream, but don't read the data yet */ data->conn = daap_command_init_stream (data->host, data->port, login_data->session_id, login_data->revision_id, login_data->request_id, dbid, command, &filesize); if (! data->conn) { goto init_error; } login_data->request_id++; metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE; xmms_xform_metadata_set_int (xform, metakey, filesize); xmms_xform_private_data_set (xform, data); xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE, "application/octet-stream", XMMS_STREAM_TYPE_END); g_slist_foreach (dbid_list, (GFunc) cc_item_record_free, NULL); g_slist_free (dbid_list); g_free (command); return TRUE; init_error: if (data) { if (data->host) g_free (data->host); g_free (data); } return FALSE; }