コード例 #1
0
ファイル: id3.c プロジェクト: eggpi/xmms2-guilherme
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);
	}
}
コード例 #2
0
ファイル: flac.c プロジェクト: dreamerc/xmms2
/* 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);
			}
		}
	}
}
コード例 #3
0
ファイル: id3.c プロジェクト: eggpi/xmms2-guilherme
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);
	}
}
コード例 #4
0
ファイル: wave.c プロジェクト: Reilithion/xmms2-reilithion
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);
}
コード例 #5
0
ファイル: xform.c プロジェクト: mantaraya36/xmms2-mantaraya36
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);
	}
}
コード例 #6
0
ファイル: musepack.c プロジェクト: kfihihc/xmms2-devel
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);
    }
}
コード例 #7
0
ファイル: samba.c プロジェクト: Malvineous/xmms2-devel
/*
 * 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;
}
コード例 #8
0
ファイル: asf.c プロジェクト: vdust/xmms2-devel
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;
}
コード例 #9
0
ファイル: sid.c プロジェクト: eggpi/xmms2-guilherme
/**
 * @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);

}
コード例 #10
0
ファイル: speex.c プロジェクト: randalboyle/xmms2-devel
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);
}
コード例 #11
0
ファイル: mp4.c プロジェクト: Malvineous/xmms2-devel
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);
		}
	}
}
コード例 #12
0
ファイル: apev2.c プロジェクト: dsheeler/xmms2
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;
}
コード例 #13
0
ファイル: apev2.c プロジェクト: dsheeler/xmms2
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;
}
コード例 #14
0
ファイル: asf.c プロジェクト: vdust/xmms2-devel
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;
}
コード例 #15
0
ファイル: metadata.c プロジェクト: eggpi/xmms2-guilherme
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;
}
コード例 #16
0
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;
}
コード例 #17
0
ファイル: id3.c プロジェクト: dsheeler/xmms2
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);
}
コード例 #18
0
ファイル: metadata.c プロジェクト: eggpi/xmms2-guilherme
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;
}
コード例 #19
0
ファイル: id3.c プロジェクト: Reilithion/xmms2-reilithion
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);
}
コード例 #20
0
ファイル: faad.c プロジェクト: kfihihc/xmms2-devel
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);
	}
コード例 #21
0
ファイル: id3.c プロジェクト: eggpi/xmms2-guilherme
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);
	}

}
コード例 #22
0
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);
}
コード例 #23
0
ファイル: cdda.c プロジェクト: kfihihc/xmms2-devel
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;
}
コード例 #24
0
ファイル: mad.c プロジェクト: eggpi/xmms2-guilherme
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;
}
コード例 #25
0
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);
}
コード例 #26
0
ファイル: gvfs.c プロジェクト: kfihihc/xmms2-devel
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;
}
コード例 #27
0
ファイル: flac.c プロジェクト: dreamerc/xmms2
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;

}
コード例 #28
0
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.
	 */
}
コード例 #29
0
ファイル: gme_xform.cpp プロジェクト: kfihihc/xmms2-devel
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;
}
コード例 #30
0
ファイル: daap_xform.c プロジェクト: kfihihc/xmms2-devel
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;
}