bool
mpd_run_send_message(struct mpd_connection *connection,
const char *channel, const char *text)
{
return mpd_run_check(connection) &&
mpd_send_send_message(connection, channel, text) &&
mpd_response_finish(connection);
}
bool
mpd_run_prio_range(struct mpd_connection *connection, int priority,
unsigned start, unsigned end)
{
return mpd_run_check(connection) &&
mpd_send_prio_range(connection, priority, start, end) &&
mpd_response_finish(connection);
}
bool
mpd_run_delete_range(struct mpd_connection *connection,
unsigned start, unsigned end)
{
return mpd_run_check(connection) &&
mpd_send_delete_range(connection, start, end) &&
mpd_response_finish(connection);
}
bool
mpd_run_seek_id(struct mpd_connection *connection,
unsigned song_id, unsigned t)
{
return mpd_run_check(connection) &&
mpd_send_seek_id(connection, song_id, t) &&
mpd_response_finish(connection);
}
bool
mpd_run_prio_id(struct mpd_connection *connection, int priority,
unsigned id)
{
return mpd_run_check(connection) &&
mpd_send_prio_id(connection, priority, id) &&
mpd_response_finish(connection);
}
Song Connection::GetCurrentSong()
{
prechecksNoCommandsList();
mpd_send_current_song(m_connection.get());
mpd_song *s = mpd_recv_song(m_connection.get());
mpd_response_finish(m_connection.get());
checkErrors();
return Song(s);
}
Song Connection::GetSong(const std::string &path)
{
prechecksNoCommandsList();
mpd_send_list_all_meta(m_connection.get(), path.c_str());
mpd_song *s = mpd_recv_song(m_connection.get());
mpd_response_finish(m_connection.get());
checkErrors();
return Song(s);
}
void Connection::CommitCommandsList()
{
prechecks();
assert(m_command_list_active);
mpd_command_list_end(m_connection.get());
mpd_response_finish(m_connection.get());
m_command_list_active = false;
checkErrors();
}
char *
getmpdstat() {
struct mpd_song * song = NULL;
const char * title = NULL;
const char * artist = NULL;
const char * uri = NULL;
const char * titletag = NULL;
const char * artisttag = NULL;
char * retstr = NULL;
int elapsed = 0, total = 0;
struct mpd_connection * conn ;
if (!(conn = mpd_connection_new("localhost", 0, 30000)) ||
mpd_connection_get_error(conn)){
return smprintf("");
}
mpd_command_list_begin(conn, true);
mpd_send_status(conn);
mpd_send_current_song(conn);
mpd_command_list_end(conn);
struct mpd_status* theStatus = mpd_recv_status(conn);
if ((theStatus) && (mpd_status_get_state(theStatus) == MPD_STATE_PLAY)) {
mpd_response_next(conn);
song = mpd_recv_song(conn);
titletag = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
artisttag = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);
title = smprintf("%s",titletag);
artist = smprintf("%s",artisttag);
uri = smprintf("%s",mpd_song_get_uri(song));
elapsed = mpd_status_get_elapsed_time(theStatus);
total = mpd_status_get_total_time(theStatus);
mpd_song_free(song);
/* If the song isn't tagged, then just use the filename */
if(artisttag == NULL && titletag == NULL) {
retstr = smprintf("%s[%s%s%s | %s%.2d:%.2d%s/%.2d:%.2d%s]",
colcyan, colyellow, uri, colcyan,
colbyellow, elapsed/60, elapsed%60,
colyellow, total/60, total%60, colcyan);
} else {
retstr = smprintf("%s[%s%s%s | %s%s%s | %s%.2d:%.2d%s/%.2d:%.2d%s]",
colcyan, colyellow, artist, colcyan, colred, title, colcyan,
colbyellow, elapsed/60, elapsed%60,
colyellow, total/60, total%60, colcyan);
}
free((char*)title);
free((char*)artist);
free((char*)uri);
}
else retstr = smprintf("");
mpd_response_finish(conn);
mpd_connection_free(conn);
return retstr;
}
static void stopSong()
{
mpd_update();
if (currentSong != NULL) {
if ((!mpd_run_stop(conn))
|| (!mpd_response_finish(conn))) {
mpd_printerror("run_stop");
}
}
}
void Connection::Delete(unsigned pos)
{
prechecks();
mpd_send_delete(m_connection.get(), pos);
if (!m_command_list_active)
{
mpd_response_finish(m_connection.get());
checkErrors();
}
}
void Connection::PlaylistDelete(const std::string &playlist, unsigned pos)
{
prechecks();
mpd_send_playlist_delete(m_connection.get(), playlist.c_str(), pos);
if (!m_command_list_active)
{
mpd_response_finish(m_connection.get());
checkErrors();
}
}
static void pauseSong()
{
mpd_update();
if (currentSong != NULL) {
if ((!mpd_send_pause(conn, l_state == MPD_STATE_PAUSE ? 0 : 1))
|| (!mpd_response_finish(conn))) {
mpd_printerror("send_pause");
}
}
}
static void prevSong()
{
mpd_update();
if (currentSong != NULL) {
if ((!mpd_run_previous(conn))
|| (!mpd_response_finish(conn))) {
mpd_printerror("run_previous");
}
}
}
static gboolean
lmc_idle(G_GNUC_UNUSED GIOChannel *source,
G_GNUC_UNUSED GIOCondition condition,
G_GNUC_UNUSED gpointer data)
{
bool success;
enum mpd_idle idle;
assert(idle_source_id != 0);
assert(g_mpd != NULL);
assert(mpd_connection_get_error(g_mpd) == MPD_ERROR_SUCCESS);
idle_source_id = 0;
idle = mpd_recv_idle(g_mpd, false);
success = mpd_response_finish(g_mpd);
if (!success && mpd_connection_get_error(g_mpd) == MPD_ERROR_SERVER &&
mpd_connection_get_server_error(g_mpd) == MPD_SERVER_ERROR_UNKNOWN_CMD &&
mpd_connection_clear_error(g_mpd)) {
/* MPD does not recognize the "idle" command - disable
it for this connection */
g_message("MPD does not support the 'idle' command - "
"falling back to polling\n");
idle_supported = false;
lmc_schedule_update();
return false;
}
if (!success) {
lmc_failure();
lmc_schedule_reconnect();
return false;
}
#if LIBMPDCLIENT_CHECK_VERSION(2,5,0)
if (subscribed && (idle & MPD_IDLE_MESSAGE) != 0 &&
!lmc_read_messages()) {
lmc_failure();
lmc_schedule_reconnect();
return false;
}
#endif
if (idle & MPD_IDLE_PLAYER)
/* there was a change: query MPD */
lmc_schedule_update();
else
/* nothing interesting: re-enter idle */
lmc_schedule_idle();
return false;
}
void mpd_say_status(void)
{
gchar *state;
gchar *artist, *title;
if (!mpd.conn) {
irc_say("Not connected to MPD");
return;
}
if (mpd.status)
mpd_status_free(mpd.status);
mpd_run_noidle(mpd.conn);
mpd.status = mpd_run_status(mpd.conn);
if (!mpd_response_finish(mpd.conn)) {
mpd_report_error();
return;
}
mpd_send_idle_mask(mpd.conn, MPD_IDLE_PLAYER);
switch (mpd_status_get_state(mpd.status)) {
case MPD_STATE_STOP:
state = g_strdup("stopped"); break;
case MPD_STATE_PLAY:
state = g_strdup("playing"); break;
case MPD_STATE_PAUSE:
state = g_strdup("paused"); break;
default:
state = g_strdup("unknown"); break;
}
if (mpd.song) {
artist = g_strdup(mpd_song_get_tag(mpd.song, MPD_TAG_ARTIST,
0));
title = g_strdup(mpd_song_get_tag(mpd.song, MPD_TAG_TITLE, 0));
} else {
artist = g_strdup("");
title = g_strdup("");
}
irc_say("[%s] %s - %s (%i:%02i/%i:%02i) | repeat: %sabled | "
"random: %sabled | announce: %sabled",
state, artist, title,
mpd_status_get_elapsed_time(mpd.status) / 60,
mpd_status_get_elapsed_time(mpd.status) % 60,
mpd_status_get_total_time(mpd.status) / 60,
mpd_status_get_total_time(mpd.status) % 60,
(mpd_status_get_repeat(mpd.status) ? "en" : "dis"),
(mpd_status_get_random(mpd.status) ? "en" : "dis"),
(prefs.announce ? "en" : "dis"));
g_free(state);
g_free(artist);
g_free(title);
}
unsigned mpd_get_queue_length()
{
unsigned length = 0;
struct mpd_status *status = mpd_run_status(mpd.conn);
if (status != NULL) {
length = mpd_status_get_queue_length(status);
mpd_status_free(status);
}
mpd_response_finish(mpd.conn);
return length;
}
static void toggleRandom()
{
mpd_update();
if (currentSong != NULL) {
l_randomEnabled = !l_randomEnabled;
if ((!mpd_run_random(conn, l_randomEnabled))
|| (!mpd_response_finish(conn))) {
mpd_printerror("run_random");
}
}
}
static void toggleConsume()
{
mpd_update();
if (currentSong != NULL) {
l_consumeEnabled = !l_consumeEnabled;
if ((!mpd_run_consume(conn, l_consumeEnabled))
|| (!mpd_response_finish(conn))) {
mpd_printerror("run_consume");
}
}
}
int main() {
char fullpath[100], text[100];
char *buf = NULL, *sub = NULL, *state = NULL;
conn = mpd_connection_new(NULL, 0, 10000);
notify = notify_notification_new(NULL, NULL, NULL);
notify_init("mpdnotify");
while(mpd_run_idle_mask(conn, MPD_IDLE_PLAYER)) {
mpd_command_list_begin(conn, true);
mpd_send_status(conn);
mpd_send_current_song(conn);
mpd_command_list_end(conn);
status = mpd_recv_status(conn);
if(mpd_status_get_state(status) == MPD_STATE_PLAY)
state = "Playing:";
else if(mpd_status_get_state(status) == MPD_STATE_PAUSE)
state = "Paused:";
else
state = "Stopped:";
mpd_response_next(conn);
song = mpd_recv_song(conn);
if(song) {
artist = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);
title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
path = mpd_song_get_uri(song);
sprintf(text, "%s - %s", artist, title);
buf = fullpath;
sub = strrchr(path, '/');
buf = strcpy(buf, mpdroot);
buf = strncat(buf, path, strlen(path) - strlen(sub) + 1);
buf = strcat(buf, albumart);
icon = gdk_pixbuf_new_from_file(fullpath, NULL);
if(icon)
notify_notification_update(notify, state, text, NULL);
else
notify_notification_update(notify, state, text, "sound");
notify_notification_set_icon_from_pixbuf(notify, icon);
notify_notification_show(notify, &gerror);
mpd_song_free(song);
}
mpd_response_finish(conn);
}
mpd_connection_free(conn);
notify_uninit();
return 0;
}
char *
get_mpd(void) {
struct mpd_connection *con;
struct mpd_status *status;
struct mpd_song *song;
int status_type;
char *res;
const char *artist = NULL, *title = NULL;
con = mpd_connection_new(NULL, 0, 30000);
if(mpd_connection_get_error(con)) {
mpd_connection_free(con);
return NO_MPD;
}
mpd_command_list_begin(con, true);
mpd_send_status(con);
mpd_send_current_song(con);
mpd_command_list_end(con);
status = mpd_recv_status(con);
if(!status) {
mpd_connection_free(con);
return NO_MPD;
}
mpd_response_next(con);
song = mpd_recv_song(con);
title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
if(!title)
title = mpd_song_get_uri(song);
artist = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);
status_type = mpd_status_get_state(status);
switch(status_type) {
case(MPD_STATE_PLAY):
res = smprintf(MPD, "Playing", artist, title);
break;
case(MPD_STATE_PAUSE):
res = smprintf(MPD, "Paused", artist, title);
break;
case(MPD_STATE_STOP):
res = smprintf(MPD, "Stopped", artist, title);
break;
default:
res = NO_MPD;
break;
}
mpd_song_free(song);
mpd_response_finish(con);
mpd_status_free(status);
mpd_connection_free(con);
return res;
}
void Connection::PlaylistMove(const std::string &path, int from, int to)
{
prechecks();
if (m_command_list_active)
mpd_send_playlist_move(m_connection.get(), path.c_str(), from, to);
else
{
mpd_send_playlist_move(m_connection.get(), path.c_str(), from, to);
mpd_response_finish(m_connection.get());
checkErrors();
}
}
unsigned
mpd_run_rescan(struct mpd_connection *connection, const char *path)
{
unsigned id;
if (!mpd_run_check(connection) || !mpd_send_rescan(connection, path))
return 0;
id = mpd_recv_update_id(connection);
return id != 0 && mpd_response_finish(connection)
? id : 0;
}
int Connection::noidle()
{
checkConnection();
int flags = 0;
if (m_idle && mpd_send_noidle(m_connection.get()))
{
m_idle = false;
flags = mpd_recv_idle(m_connection.get(), true);
mpd_response_finish(m_connection.get());
checkErrors();
}
return flags;
}
static void volUp()
{
mpd_update();
if (currentSong != NULL) {
l_volume += 5;
if (l_volume > 100)
l_volume = 100;
if ((!mpd_run_set_volume(conn, l_volume))
|| (!mpd_response_finish(conn))) {
mpd_printerror("set_volume");
}
}
}
std::string Connection::GetReplayGainMode()
{
prechecksNoCommandsList();
mpd_send_command(m_connection.get(), "replay_gain_status", NULL);
std::string result;
if (mpd_pair *pair = mpd_recv_pair_named(m_connection.get(), "replay_gain_mode"))
{
result = pair->value;
mpd_return_pair(m_connection.get(), pair);
}
mpd_response_finish(m_connection.get());
checkErrors();
return result;
}
int cmd_add (int argc, char ** argv, struct mpd_connection *conn )
{
if (contains_absolute_path(argc, argv) && !path_prepare(conn))
printErrorAndExit(conn);
int i;
if (!mpd_command_list_begin(conn, false))
printErrorAndExit(conn);
for(i=0;i<argc;i++) {
strip_trailing_slash(argv[i]);
const char *path = argv[i];
const char *relative_path = to_relative_path(path);
if (relative_path != NULL)
path = relative_path;
if (options.verbosity >= V_VERBOSE)
printf("adding: %s\n", path);
mpd_send_add(conn, charset_to_utf8(path));
}
if (!mpd_command_list_end(conn))
printErrorAndExit(conn);
if (!mpd_response_finish(conn)) {
#if LIBMPDCLIENT_CHECK_VERSION(2,4,0)
if (mpd_connection_get_error(conn) == MPD_ERROR_SERVER) {
/* check which of the arguments has failed */
unsigned location =
mpd_connection_get_server_error_location(conn);
if (location < (unsigned)argc) {
/* we've got a valid location from the
server */
const char *message =
mpd_connection_get_error_message(conn);
message = charset_from_utf8(message);
fprintf(stderr, "error adding %s: %s\n",
argv[location], message);
exit(EXIT_FAILURE);
}
}
#endif
printErrorAndExit(conn);
}
return 0;
}
static int fetch_items(MENU_SEARCH *menu,char *str,CLIENT_OBJECT *cli,DB_OBJECT *db)
{
if (!(str && strlen(str)))
return 1;
/* send query */
if (!mpd_search_db_songs(cli->conn,false))
clear_or_exit_on_error(cli->conn);
if (!mpd_search_add_tag_constraint(cli->conn,MPD_OPERATOR_DEFAULT,MPD_TAG_TITLE,str))
clear_or_exit_on_error(cli->conn);
if (!mpd_search_commit(cli->conn))
clear_or_exit_on_error(cli->conn);
/* process response */
int block = 1024;
menu->items = (MENU_SEARCH_ITEM*)calloc(block,sizeof(MENU_SEARCH_ITEM));
struct mpd_song *song;
int i = 0;
while ((song = mpd_recv_song(cli->conn))) {
/* realloc if memory not enough */
if (i >= block) {
block *= 2;
menu->items = (MENU_SEARCH_ITEM*)realloc(menu->items,block*sizeof(MENU_SEARCH_ITEM));
}
unsigned id = mpd_song_get_id(song);
const char *uri = mpd_song_get_uri(song);
const char *title = mpd_song_get_tag(song,MPD_TAG_TITLE,0);
menu->items[i].id = id;
menu->items[i].title = (char *)malloc((strlen(title)+1)*sizeof(char));
strcpy(menu->items[i].title,title);
menu->items[i++].node = get_node_by_uri(db,uri);
mpd_song_free(song);
}
if (mpd_connection_get_error(cli->conn) == MPD_ERROR_SUCCESS)
mpd_response_finish(cli->conn);
else
clear_or_exit_on_error(cli->conn);
menu->num = i;
return 0;
}
void mpd_stop(void)
{
if (!mpd.conn) {
irc_say("Not connected to MPD");
return;
}
mpd_run_noidle(mpd.conn);
mpd_run_stop(mpd.conn);
if (!mpd_response_finish(mpd.conn)) {
mpd_report_error();
return;
}
mpd_send_idle_mask(mpd.conn, MPD_IDLE_PLAYER);
}
static void volDown()
{
mpd_update();
if (currentSong != NULL) {
if (l_volume > 5)
l_volume -= 5;
else
l_volume = 0;
if ((!mpd_run_set_volume(conn, l_volume))
|| (!mpd_response_finish(conn))) {
mpd_printerror("set_volume");
}
}
}