自学教程：C++ xmms_xform_metadata_set_int函数代码示例

static voidhandle_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 voidhandle_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 voidhandle_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 voidxmms_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 voidoutdata_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 voidxmms_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 gbooleanxmms_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 gbooleanxmms_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 voidxmms_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 voidxmms_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 voidxmms_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 gbooleanxmms_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 gbooleanxmms_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 gbooleanxmms_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;}

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

gbooleanxmms_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 voidhandle_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 voidxmms_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 voidhandle_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 voidxmms_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 gbooleanxmms_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);//.........这里部分代码省略.........

static gbooleanxmms_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);//.........这里部分代码省略.........

static voidxmms_vorbis_set_duration (xmms_xform_t *xform, guint dur){	xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION,	                             dur * 1000);}

static gbooleanxmms_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 gbooleanxmms_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;//.........这里部分代码省略.........

static voidxmms_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 gbooleanxmms_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)) {//.........这里部分代码省略.........

static gbooleanxmms_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;}