int main(int argc, const char* const argv[])
{
if (argc > 2 || (argc == 2 && strncmp(argv[1], "-h", 2) == 0)) {
usage();
return 0;
}
conn = mpd_connection_new(NULL, 0, 0);
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) {
mpd_connection_free(conn);
fputs("Could not connect to MPD.\n", stderr);
return 0;
}
stat = mpd_run_status(conn);
if (!(song = mpd_run_current_song(conn))) {
fputs("No song playing.\n", stderr);
return 0;
}
if (argc == 1)
print_info(DEFAULT_FMT);
else
print_info(argv[1]);
if (song)
mpd_song_free(song);
mpd_status_free(stat);
mpd_connection_free(conn);
return 0;
}
int
main(int argc, char**argv)
{
struct mpd_connection *idle_con;
struct mpd_connection *cmd_con;
connect(&idle_con);
connect(&cmd_con);
pthread_t t;
for (;; )
{
// pthread_create(&t, NULL, &changeVolume, (void *) cmd_con);
printf("Enter idle loop\n");
enum mpd_idle event = mpd_run_idle(idle_con);
printf("idle event : %d\n", event);
}
mpd_connection_free(idle_con);
mpd_connection_free(cmd_con);
idle_con = NULL;
cmd_con = NULL;
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 cmd_play(irc_session_t* session, const char* cmd, const char* origin, char* args) {
struct mpd_connection* conn;
conn = mpd_connection_new(NULL, 0, 30000);
if(mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) {
log_and_print("Impossible de se connecter à MPD");
mpd_connection_free(conn);
return;
}
mpd_run_play(conn);
mpd_connection_free(conn);
}
static void mpd_disconnect(void)
{
if (mpd.conn)
mpd_connection_free(mpd.conn);
mpd.conn = NULL;
irc_say("Disconnected from MPD");
}
/**
* Release resources
*/
static void scmpc_cleanup(void)
{
g_source_remove(signal_source);
if (prefs.cache_interval > 0)
g_source_remove(cache_save_source);
if (mpd.idle_source > 0)
g_source_remove(mpd.idle_source);
if (mpd.check_source > 0)
g_source_remove(mpd.check_source);
if (mpd.reconnect_source > 0)
g_source_remove(mpd.reconnect_source);
if (current_song_eligible_for_submission())
queue_add_current_song();
if (prefs.fork)
scmpc_pid_remove();
close_signal_pipe();
if (prefs.cache_interval > 0)
queue_save(NULL);
queue_cleanup();
if (mpd.song_pos)
g_timer_destroy(mpd.song_pos);
clear_preferences();
as_cleanup();
if (mpd.conn != NULL)
mpd_connection_free(mpd.conn);
}
static int
handle_error(struct mpd_connection *c)
{
assert(mpd_connection_get_error(c) != MPD_ERROR_SUCCESS);
fprintf(stderr, "%s\n", mpd_connection_get_error_message(c));
mpd_connection_free(c);
return EXIT_FAILURE;
}
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 lmc_failure(void)
{
char *msg = g_strescape(mpd_connection_get_error_message(g_mpd), NULL);
g_warning("mpd error (%u): %s\n",
mpd_connection_get_error(g_mpd), msg);
g_free(msg);
mpd_connection_free(g_mpd);
g_mpd = NULL;
}
/*
* pgmpc_reset
*
* Cleanup existing mpd context.
*/
static void
pgmpc_reset(void)
{
if (mpd_conn)
mpd_connection_free(mpd_conn);
if (mpd_status)
mpd_status_free(mpd_status);
mpd_conn = NULL;
mpd_status = NULL;
}
int mgr_handle_mpd_error() {
if (conn != NULL) {
fprintf(stderr, "MPD ERROR: %s\n", mpd_connection_get_error_message(conn));
mpd_connection_free(conn);
conn = NULL;
} else
fprintf(stderr, "MPD ERROR: unknown error (mgr_handle_mpd_error)\n");
return EXIT_FAILURE;
}
/* Disconnect from the MPD server
*/
void Player::disconnectToMpd()
{
if (conn == NULL)
{
return;
}
mpd_connection_free(conn);
conn = NULL;
}
int del_client(CLIENT_OBJECT *cli) {
mpd_stats_free(cli->stats);
if (cli->song)
mpd_song_free(cli->song);
mpd_status_free(cli->status);
mpd_connection_free(cli->conn);
free(cli);
return 0;
}
void plugin_exit_mpd(void)
{
if (plugin_enabled == 1) {
debug("[MPD] disconnect from mpd");
if (currentSong != NULL)
mpd_song_free(currentSong);
}
if (conn != NULL)
mpd_connection_free(conn);
charset_close();
}
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;
}
void mpd_poll(struct mg_server *s)
{
switch (mpd.conn_state) {
case MPD_DISCONNECTED:
/* Try to connect */
fprintf(stdout, "MPD Connecting to %s:%d\n", mpd.host, mpd.port);
mpd.conn = mpd_connection_new(mpd.host, mpd.port, 3000);
if (mpd.conn == NULL) {
fprintf(stderr, "Out of memory.");
mpd.conn_state = MPD_FAILURE;
return;
}
if (mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS) {
fprintf(stderr, "MPD connection: %s\n", mpd_connection_get_error_message(mpd.conn));
mg_iterate_over_connections(s, mpd_notify_callback,
(void *)mpd_connection_get_error_message(mpd.conn));
mpd.conn_state = MPD_FAILURE;
return;
}
if(mpd.password && !mpd_run_password(mpd.conn, mpd.password))
{
fprintf(stderr, "MPD connection: %s\n", mpd_connection_get_error_message(mpd.conn));
mg_iterate_over_connections(s, mpd_notify_callback,
(void *)mpd_connection_get_error_message(mpd.conn));
mpd.conn_state = MPD_FAILURE;
return;
}
fprintf(stderr, "MPD connected.\n");
mpd_connection_set_timeout(mpd.conn, 10000);
mpd.conn_state = MPD_CONNECTED;
break;
case MPD_FAILURE:
fprintf(stderr, "MPD connection failed.\n");
case MPD_DISCONNECT:
case MPD_RECONNECT:
if(mpd.conn != NULL)
mpd_connection_free(mpd.conn);
mpd.conn = NULL;
mpd.conn_state = MPD_DISCONNECTED;
break;
case MPD_CONNECTED:
mpd.buf_size = mpd_put_state(mpd.buf, &mpd.song_id, &mpd.queue_version);
mg_iterate_over_connections(s, mpd_notify_callback, NULL);
break;
}
}
static bool check_error(struct mpd_connection *client)
{
if (mpd_connection_get_error(client) != MPD_ERROR_SUCCESS) {
printf("Error: %s (Retry in 1 second...)\n",
mpd_connection_get_error_message(client));
if (!mpd_connection_clear_error(client)) {
mpd_connection_free(client);
sleep(1);
return true;
}
}
return (client == NULL);
}
void printErrorAndExit(struct mpd_connection *conn)
{
assert(mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS);
const char *message = mpd_connection_get_error_message(conn);
#if 0
if (mpd_connection_get_error(conn) == MPD_ERROR_SERVER)
/* messages received from the server are UTF-8; the
rest is either US-ASCII or locale */
message = charset_from_utf8(message);
#endif
fprintf(stderr, "mpd error: %s\n", message);
mpd_connection_free(conn);
exit(EXIT_FAILURE);
}
bool check_error(struct mpd_connection *con, FILE *logfile, bool exit_on_failure)
{
if (mpd_connection_get_error(con) != MPD_ERROR_SUCCESS) {
if (logfile)
fprintf(logfile, "MPD error: %s\n", mpd_connection_get_error_message(con));
if (exit_on_failure || !mpd_connection_clear_error(con)) {
mpd_connection_free(con);
exit(EXIT_FAILURE);
}
return true;
}
return false;
}
void mpd_poll()
{
// printf("%d\n", mpd.conn_state);
switch (mpd.conn_state) {
case MPD_DISCONNECTED:
syslog(LOG_INFO, "%s - MPD Connecting...\n", __func__);
mpd.conn = mpd_connection_new(NULL, NULL, 3000);
if (mpd.conn == NULL) {
syslog(LOG_ERR, "%s - Out of memory.", __func__);
mpd.conn_state = MPD_FAILURE;
return;
}
if (mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS) {
syslog(LOG_ERR, "%s - MPD connection: %s\n", __func__,
mpd_connection_get_error_message(mpd.conn));
mpd.conn_state = MPD_FAILURE;
return;
}
syslog(LOG_INFO, "%s - MPD connected.\n", __func__);
mpd_connection_set_timeout(mpd.conn, 10000);
mpd.conn_state = MPD_CONNECTED;
break;
case MPD_FAILURE:
case MPD_DISCONNECT:
case MPD_RECONNECT:
syslog(LOG_ERR, "%s - MPD (dis)reconnect or failure\n", __func__);
if(mpd.conn != NULL)
mpd_connection_free(mpd.conn);
mpd.conn = NULL;
mpd.conn_state = MPD_DISCONNECTED;
break;
case MPD_CONNECTED:
mpd_put_state();
//TODO: display status
/* if (queue_is_empty) {
queue_is_empty = 0;
get_random_song(mpd.conn, str, rcm.file_path);
if (strcmp(str, "") != 0) {
syslog(LOG_DEBUG, "%s: add random song %s\n", __func__, str);
mpd_run_add(mpd.conn, str);
}
}*/
break;
default:
syslog(LOG_INFO, "%s - mpd.conn_state %i\n", __func__, mpd.conn_state);
}
}
int main(int argc, char ** argv)
{
struct mpd_connection *conn = setup_connection();
int id = -1;
if (!mpd_send_list_all_meta(conn, "radio"))
printErrorAndExit(conn);
print_entity_list(conn, MPD_ENTITY_TYPE_SONG);//MPD_ENTITY_TYPE_UNKNOWN);
id = find_songname_id(conn, "artist Radiohead");
printf("id = %i\n", id);
mpd_connection_free(conn);
return 0;
}
static void mpd_printerror(const char *cmd)
{
const char *s;
if (conn) {
//assert(mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS);
s = mpd_connection_get_error_message(conn);
if (mpd_connection_get_error(conn) == MPD_ERROR_SERVER)
/* messages received from the server are UTF-8; the
rest is either US-ASCII or locale */
s = charset_from_utf8(s);
error("[MPD] %s to [%s]:[%i] failed : [%s]", cmd, host, iport, s);
mpd_connection_free(conn);
conn = NULL;
}
}
/*new_connection*/
int new_connection(struct mpd_connection **conn)
{
*conn = mpd_connection_new(NULL, 0, 30000);
if (*conn == NULL)
{
printf("nd new_connection %s\n", "Out of memory");
return -1;
}
if (mpd_connection_get_error(*conn) != MPD_ERROR_SUCCESS)
{
printf("nd new_connection %s\n", mpd_connection_get_error_message(*conn));
mpd_connection_free(*conn);
*conn = NULL;
return -1;
}
return 0;
}
bool
CMPD::Connect()
{
if(_conn)
mpd_connection_free(_conn);
_conn = mpd_connection_new(Config->getMHost().c_str(), Config->getMPort(), 0);
_connected = _conn && mpd_connection_get_error(_conn) == MPD_ERROR_SUCCESS;
if(_connected && Config->getMPassword().size() > 0) {
_connected &= mpd_run_password(_conn, Config->getMPassword().c_str());
}
if(_connected)
mpd_run_subscribe(_conn, "mpdas");
return _connected;
}
static int
connect(struct mpd_connection **conn)
{
*conn = mpd_connection_new(NULL, 0, 30000);
if (*conn == NULL)
{
LOG_ERROR("%s", "Out of memory");
return -1;
}
if (mpd_connection_get_error(*conn) != MPD_ERROR_SUCCESS)
{
LOG_ERROR("%s", mpd_connection_get_error_message(*conn));
mpd_connection_free(*conn);
*conn = NULL;
return -1;
}
return 1;
}
bool CMPD::Connect()
{
if(_conn)
mpd_connection_free(_conn);
_conn = mpd_connection_new(_cfg->Get("host").c_str(), _cfg->GetInt("port"), 0);
_connected = _conn && mpd_connection_get_error(_conn) == MPD_ERROR_SUCCESS;
if(_connected && _cfg->Get("mpdpassword").size() > 0) {
_connected &= mpd_run_password(_conn, _cfg->Get("mpdpassword").c_str());
}
else if(!_connected) {
eprintf("MPD connection error: %s", mpd_connection_get_error_message(_conn));
}
if(_connected)
mpd_run_subscribe(_conn, "mpdas");
return _connected;
}
void lmc_disconnect(void)
{
if (reconnect_source_id != 0)
g_source_remove(reconnect_source_id);
if (update_source_id != 0)
g_source_remove(update_source_id);
if (idle_source_id != 0)
g_source_remove(idle_source_id);
if (g_mpd) {
mpd_connection_free(g_mpd);
g_mpd = NULL;
}
if (current_song != NULL) {
mpd_song_free(current_song);
current_song = NULL;
}
}
/*
* returns: 0 - error; 1 - ok
*/
int mgr_mpd_connect( void ) {
if (conn != NULL) {
if (DEBUG)
fprintf(stderr, "DEBUG: [mgr-thread] mpd: close open connection\n");
mpd_connection_free(conn);
conn = NULL;
}
conn = mpd_connection_new(NULL, 0, 30000);
if (conn == NULL || mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) {
fprintf(stderr, "ERROR: MPD: Unable to connect to MPD\n");
return 0;
}
// SETUP mode: repeat:yes, random:yes
if (!mpd_run_repeat(conn, true) || !mpd_run_random(conn, true)) {
fprintf(stderr, "ERROR: MPD: Unable to change mode for the created MPD connection\n");
mgr_handle_mpd_error();
return 0;
}
if (DEBUG)
fprintf(stderr, "DEBUG: [mgr-thread] mpd: new MPD connection was created\n");
if (DEBUG)
fprintf(stderr, "DEBUG: [mgr-thread] mpd: database update started\n");
// Send update command
if (!mpd_run_update(conn, NULL)) { // ALL MUSIC in the folder
fprintf(stderr, "ERROR: MPD: Unable to update MPD database\n");
mgr_handle_mpd_error();
return 0;
}
return 1;
}
int
main(int argc, char *argv[])
{
char *password = NULL;
struct mpd_connection *conn = mpd_connection_new(mpd_check_host(NULL, &password), 0, 0);
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS)
{
fprintf(stderr,"%s: %s\n", argv[0], mpd_connection_get_error_message(conn));
return 1;
}
if (password != NULL)
{
if (mpd_run_password(conn, password) == false)
{
fprintf(stderr, "%s: mpd_run_password %s\n", argv[0],
mpd_connection_get_error_message(conn));
free(password);
return 2;
}
}
if (notify_init("MPD_Notification") == 0)
{
fprintf(stderr, "%s: Cannot initialize libnotify.\n", argv[0]);
return 3;
}
infinite_loop(conn);
mpd_connection_free(conn);
free(password);
notify_uninit();
return 0;
}
bool mpd_is_in_queue(const char *uri)
{
bool res = false;
struct mpd_entity *entity;
struct mpd_connection *conn = mpd_connection_new(NULL, NULL, 3000);
if (conn == NULL) {
syslog(LOG_ERR, "%s - Out of memory.", __func__);
goto DONE;
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) {
syslog(LOG_ERR, "%s - MPD connection: %s\n", __func__,
mpd_connection_get_error_message(conn));
goto DONE;
}
if (!mpd_send_list_queue_meta(conn)) {
syslog(LOG_ERR, "%s: %s", __func__, mpd_connection_get_error_message(conn));
mpd_connection_clear_error(conn);
goto DONE;
}
while((entity = mpd_recv_entity(conn)) != NULL) {
const struct mpd_song *song;
if(mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG && !res) {
song = mpd_entity_get_song(entity);
if (strcmp(mpd_song_get_uri(song), uri) == 0) {
syslog(LOG_INFO, "%s: %s is already in the queue", __func__, uri);
res = true;
}
}
mpd_entity_free(entity);
}
DONE:
if(conn != NULL)
mpd_connection_free(conn);
return res;
}
