xmmsctrl.c

xmms-1.2.10.tar.gz学习使用的就下吧

void xmms_remote_playlist_clear(gint session)
{
	remote_cmd(session, CMD_PLAYLIST_CLEAR);
}

gint xmms_remote_get_output_time(gint session)
{
	return remote_get_gint(session, CMD_GET_OUTPUT_TIME);
}

void xmms_remote_jump_to_time(gint session, gint pos)
{
	remote_send_guint32(session, CMD_JUMP_TO_TIME, pos);
}

void xmms_remote_get_volume(gint session, gint * vl, gint * vr)
{
	ServerPktHeader pkt_hdr;
	gint fd;
	gpointer data;

	if ((fd = xmms_connect_to_session(session)) == -1)
		return;

	remote_send_packet(fd, CMD_GET_VOLUME, NULL, 0);
	data = remote_read_packet(fd, &pkt_hdr);
	if (data)
	{
		*vl = ((guint32 *) data)[0];
		*vr = ((guint32 *) data)[1];
		g_free(data);
	}
	remote_read_ack(fd);
	close(fd);
}

gint xmms_remote_get_main_volume(gint session)
{
	gint vl, vr;

	xmms_remote_get_volume(session, &vl, &vr);

	return (vl > vr) ? vl : vr;
}

gint xmms_remote_get_balance(gint session)
{
	return remote_get_gint(session, CMD_GET_BALANCE);
}

void xmms_remote_set_volume(gint session, gint vl, gint vr)
{
	gint fd;
	guint32 v[2];

	if (vl < 0)
		vl = 0;
	if (vl > 100)
		vl = 100;
	if (vr < 0)
		vr = 0;
	if (vr > 100)
		vr = 100;

	if ((fd = xmms_connect_to_session(session)) == -1)
		return;
	v[0] = vl;
	v[1] = vr;
	remote_send_packet(fd, CMD_SET_VOLUME, v, 2 * sizeof (guint32));
	remote_read_ack(fd);
	close(fd);
}

void xmms_remote_set_main_volume(gint session, gint v)
{
	gint b, vl, vr;

	b = xmms_remote_get_balance(session);

	if (b < 0)
	{
		vl = v;
		vr = (v * (100 - abs(b))) / 100;
	}
	else if (b > 0)
	{
		vl = (v * (100 - b)) / 100;
		vr = v;
	}
	else
		vl = vr = v;
	xmms_remote_set_volume(session, vl, vr);
}

void xmms_remote_set_balance(gint session, gint b)
{
	gint v, vl, vr;

	if (b < -100)
		b = -100;
	if (b > 100)
		b = 100;

	v = xmms_remote_get_main_volume(session);

	if (b < 0)
	{
		vl = v;
		vr = (v * (100 - abs(b))) / 100;
	}
	else if (b > 0)
	{
		vl = (v * (100 - b)) / 100;
		vr = v;
	}
	else
		vl = vr = v;
	xmms_remote_set_volume(session, vl, vr);
}

gchar *xmms_remote_get_skin(gint session)
{
	return remote_get_string(session, CMD_GET_SKIN);
}

void xmms_remote_set_skin(gint session, gchar * skinfile)
{
	remote_send_string(session, CMD_SET_SKIN, skinfile);
}

gchar *xmms_remote_get_playlist_file(gint session, gint pos)
{
	return remote_get_string_pos(session, CMD_GET_PLAYLIST_FILE, pos);
}

gchar *xmms_remote_get_playlist_title(gint session, gint pos)
{
	return remote_get_string_pos(session, CMD_GET_PLAYLIST_TITLE, pos);
}

gint xmms_remote_get_playlist_time(gint session, gint pos)
{
	ServerPktHeader pkt_hdr;
	gpointer data;
	gint fd, ret = 0;
	guint32 p = pos;

	if ((fd = xmms_connect_to_session(session)) == -1)
		return ret;
	remote_send_packet(fd, CMD_GET_PLAYLIST_TIME, &p, sizeof (guint32));
	data = remote_read_packet(fd, &pkt_hdr);
	if (data)
	{
		ret = *((gint *) data);
		g_free(data);
	}
	remote_read_ack(fd);
	close(fd);
	return ret;
}

void xmms_remote_get_info(gint session, gint * rate, gint * freq, gint * nch)
{
	ServerPktHeader pkt_hdr;
	gint fd;
	gpointer data;

	if ((fd = xmms_connect_to_session(session)) == -1)
		return;
	remote_send_packet(fd, CMD_GET_INFO, NULL, 0);
	data = remote_read_packet(fd, &pkt_hdr);
	if (data)
	{
		*rate = ((guint32 *) data)[0];
		*freq = ((guint32 *) data)[1];
		*nch = ((guint32 *) data)[2];
		g_free(data);
	}
	remote_read_ack(fd);
	close(fd);
}

void xmms_remote_get_eq_data(gint session)
{
	/* Obsolete */
}

void xmms_remote_set_eq_data(gint session)
{
	/* Obsolete */
}

void xmms_remote_pl_win_toggle(gint session, gboolean show)
{
	remote_send_boolean(session, CMD_PL_WIN_TOGGLE, show);
}

void xmms_remote_eq_win_toggle(gint session, gboolean show)
{
	remote_send_boolean(session, CMD_EQ_WIN_TOGGLE, show);
}

void xmms_remote_main_win_toggle(gint session, gboolean show)
{
	remote_send_boolean(session, CMD_MAIN_WIN_TOGGLE, show);
}

gboolean xmms_remote_is_main_win(gint session)
{
	return remote_get_gboolean(session, CMD_IS_MAIN_WIN);
}

gboolean xmms_remote_is_pl_win(gint session)
{
	return remote_get_gboolean(session, CMD_IS_PL_WIN);
}

gboolean xmms_remote_is_eq_win(gint session)
{
	return remote_get_gboolean(session, CMD_IS_EQ_WIN);
}

void xmms_remote_show_prefs_box(gint session)
{
	remote_cmd(session, CMD_SHOW_PREFS_BOX);
}

void xmms_remote_toggle_aot(gint session, gboolean ontop)
{
	remote_send_boolean(session, CMD_TOGGLE_AOT, ontop);
}

void xmms_remote_show_about_box(gint session)
{
	remote_cmd(session, CMD_SHOW_ABOUT_BOX);
}

void xmms_remote_eject(gint session)
{
	remote_cmd(session, CMD_EJECT);
}

void xmms_remote_playlist_prev(gint session)
{
	remote_cmd(session, CMD_PLAYLIST_PREV);
}

void xmms_remote_playlist_next(gint session)
{
	remote_cmd(session, CMD_PLAYLIST_NEXT);
}

void xmms_remote_playlist_add_url_string(gint session, gchar * string)
{
	g_return_if_fail(string != NULL);
	remote_send_string(session, CMD_PLAYLIST_ADD_URL_STRING, string);
}

void xmms_remote_playlist_ins_url_string(gint session, gchar * string, gint pos)
{
	int fd, size;
	char* packet;

	g_return_if_fail(string != NULL);

	size = strlen(string) + 1 + sizeof(int);

	if ((fd = xmms_connect_to_session(session)) == -1)
		return;

	packet = g_malloc0(size);
	*((int*) packet) = pos;
	strcpy(packet + sizeof(int), string);
	remote_send_packet(fd, CMD_PLAYLIST_INS_URL_STRING, packet, size);
	remote_read_ack(fd);
	close(fd);
	g_free(packet);
}

gboolean xmms_remote_is_running(gint session)
{
	return remote_cmd(session, CMD_PING);
}

void xmms_remote_toggle_repeat(gint session)
{
	remote_cmd(session, CMD_TOGGLE_REPEAT);
}

void xmms_remote_toggle_shuffle(gint session)
{
	remote_cmd(session, CMD_TOGGLE_SHUFFLE);
}

gboolean xmms_remote_is_repeat(gint session)
{
	return remote_get_gboolean(session, CMD_IS_REPEAT);
}

gboolean xmms_remote_is_shuffle(gint session)
{
	return remote_get_gboolean(session, CMD_IS_SHUFFLE);
}

void xmms_remote_get_eq(gint session, gfloat *preamp, gfloat **bands)
{
	ServerPktHeader pkt_hdr;
	gint fd;
	gpointer data;

	if (preamp)
		*preamp = 0.0;

	if (bands)
		*bands = NULL;

	if ((fd = xmms_connect_to_session(session)) == -1)
		return;
	remote_send_packet(fd, CMD_GET_EQ, NULL, 0);
	data = remote_read_packet(fd, &pkt_hdr);
	if (data)
	{
		if (pkt_hdr.data_length >= 11 * sizeof(gfloat))
		{
			if (preamp)
				*preamp = *((gfloat *) data);
			if (bands)
				*bands = (gfloat *) g_memdup((gfloat *)data + 1, 10 * sizeof(gfloat));
		}
		g_free(data);
	}
	remote_read_ack(fd);
	close(fd);
}

gfloat xmms_remote_get_eq_preamp(gint session)
{
	return remote_get_gfloat(session, CMD_GET_EQ_PREAMP);
}

gfloat xmms_remote_get_eq_band(gint session, gint band)
{
	ServerPktHeader pkt_hdr;
	gint fd;
	gpointer data;
	gfloat val = 0.0;

	if ((fd = xmms_connect_to_session(session)) == -1)
		return val;
	remote_send_packet(fd, CMD_GET_EQ_BAND, &band, sizeof(band));
	data = remote_read_packet(fd, &pkt_hdr);
	if (data) {
		val = *((gfloat *) data);
		g_free(data);
	}
	remote_read_ack(fd);
	close(fd);
	return val;
}

void xmms_remote_set_eq(gint session, gfloat preamp, gfloat *bands)
{
	gint fd, i;
	gfloat data[11];

	g_return_if_fail(bands != NULL);

	if ((fd = xmms_connect_to_session(session)) == -1)
		return;
	data[0] = preamp;
	for (i = 0; i < 10; i++)
		data[i + 1] = bands[i];
	remote_send_packet(fd, CMD_SET_EQ, data, sizeof(data));
	remote_read_ack(fd);
	close(fd);
}

void xmms_remote_set_eq_preamp(gint session, gfloat preamp)
{
	remote_send_gfloat(session, CMD_SET_EQ_PREAMP, preamp);
}

void xmms_remote_set_eq_band(gint session, gint band, gfloat value)
{
	gint fd;
	gchar data[sizeof(gint) + sizeof(gfloat)];

	if ((fd = xmms_connect_to_session(session)) == -1)
		return;
	*((gint *) data) = band;
	*((gfloat *) (data + sizeof(gint))) = value;
	remote_send_packet(fd, CMD_SET_EQ_BAND, data, sizeof(data));
	remote_read_ack(fd);
	close(fd);
}

void xmms_remote_quit(gint session)
{
	gint fd;

	if ((fd = xmms_connect_to_session(session)) == -1)
		return;
	remote_send_packet(fd, CMD_QUIT, NULL, 0);
	remote_read_ack(fd);
	close(fd);
}