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);
}
void print_info(const char fmt[])
{
int t;
for (int i = 0; i < strlen(fmt); ++i) {
if (fmt[i] == '%') {
switch(fmt[i+1]) {
case 'n':
if (song)
fputs(mpd_song_get_tag(song, MPD_TAG_TITLE, 0), stdout);
break;
case 'a':
if (song)
fputs(mpd_song_get_tag(song, MPD_TAG_ARTIST, 0), stdout);
break;
case 'l':
if (song)
fputs(mpd_song_get_tag(song, MPD_TAG_ALBUM, 0), stdout);
break;
case 'c':
t = mpd_status_get_elapsed_time(stat);
printf("%u:%02u", t / 60, t % 60);
break;
case 'r':
t = mpd_status_get_total_time(stat) -
mpd_status_get_elapsed_time(stat);
printf("%u:%02u", t / 60, t % 60);
break;
case 't':
t = mpd_status_get_total_time(stat);
printf("%u:%02u", t / 60, t % 60);
break;
case '%':
putchar('%');
break;
default:
putchar('%');
putchar(fmt[i+1]);
break;
}
++i;
} else {
putchar(fmt[i]);
}
}
putchar('\n');
}
int mpd_put_state(char *buffer, int *current_song_id, unsigned *queue_version)
{
struct mpd_status *status;
int len;
status = mpd_run_status(mpd.conn);
if (!status) {
fprintf(stderr, "MPD mpd_run_status: %s\n", mpd_connection_get_error_message(mpd.conn));
mpd.conn_state = MPD_FAILURE;
return 0;
}
len = snprintf(buffer, MAX_SIZE,
"{\"type\":\"state\", \"data\":{"
" \"state\":%d, \"volume\":%d, \"repeat\":%d,"
" \"single\":%d, \"consume\":%d, \"random\":%d, "
" \"songpos\": %d, \"elapsedTime\": %d, \"totalTime\":%d, "
" \"currentsongid\": %d"
"}}",
mpd_status_get_state(status),
mpd_status_get_volume(status),
mpd_status_get_repeat(status),
mpd_status_get_single(status),
mpd_status_get_consume(status),
mpd_status_get_random(status),
mpd_status_get_song_pos(status),
mpd_status_get_elapsed_time(status),
mpd_status_get_total_time(status),
mpd_status_get_song_id(status));
*current_song_id = mpd_status_get_song_id(status);
*queue_version = mpd_status_get_queue_version(status);
mpd_status_free(status);
return len;
}
void
songlist_simple_bar(void)
{
int crt_time, crt_time_perc, total_time,
fill_len, rest_len, i;
struct mpd_status *status;
WINDOW *win = specific_win(SIMPLE_PROC_BAR);
const int bar_length = win->_maxx + 1;
status = getStatus(conn);
crt_time = mpd_status_get_elapsed_time(status);
total_time = mpd_status_get_total_time(status);
mpd_status_free(status);
crt_time_perc = (total_time == 0 ? 0 : 100 * crt_time / total_time);
fill_len = crt_time_perc * bar_length / 100;
rest_len = bar_length - fill_len;
wattron(win, my_color_pairs[2]);
for(i = 0; i < fill_len; wprintw(win, "*"), i++);
wattroff(win, my_color_pairs[2]);
for(i = 0; i < rest_len; wprintw(win, "*"), i++);
}
void mpd_put_state(void)
{
struct mpd_status *status;
int len;
unsigned queue_len;
int song_pos, next_song_pos;
status = mpd_run_status(mpd.conn);
if (!status) {
syslog(LOG_ERR, "%s mpd_run_status: %s\n", __func__, mpd_connection_get_error_message(mpd.conn));
mpd.conn_state = MPD_FAILURE;
return;
}
mpd.song_pos = mpd_status_get_song_pos(status);
mpd.next_song_pos = song_pos+1; //TODO: mpd_status_get_next_song_pos(status);
mpd.queue_len = mpd_status_get_queue_length(status);
mpd.volume = mpd_status_get_volume(status);
mpd.state = mpd_status_get_state(status);
mpd.repeat = mpd_status_get_repeat(status);
mpd.single = mpd_status_get_single(status);
mpd.consume = mpd_status_get_consume(status);
mpd.random = mpd_status_get_random(status);
mpd.elapsed_time = mpd_status_get_elapsed_time(status);
mpd.total_time = mpd_status_get_total_time(status);
mpd.song_id = mpd_status_get_song_id(status);
// printf("%d\n", mpd.song_id);
mpd_status_free(status);
}
static enum mpd_state
lmc_current(struct mpd_song **song_r, unsigned *elapsed_r)
{
struct mpd_status *status;
enum mpd_state state;
struct mpd_song *song;
assert(g_mpd != NULL);
mpd_command_list_begin(g_mpd, true);
mpd_send_status(g_mpd);
mpd_send_current_song(g_mpd);
mpd_command_list_end(g_mpd);
status = mpd_recv_status(g_mpd);
if (!status) {
lmc_failure();
return MPD_STATE_UNKNOWN;
}
state = mpd_status_get_state(status);
*elapsed_r = mpd_status_get_elapsed_time(status);
mpd_status_free(status);
if (state != MPD_STATE_PLAY) {
if (!mpd_response_finish(g_mpd)) {
lmc_failure();
return MPD_STATE_UNKNOWN;
}
return state;
}
if (!mpd_response_next(g_mpd)) {
lmc_failure();
return MPD_STATE_UNKNOWN;
}
song = mpd_recv_song(g_mpd);
if (song == NULL) {
if (!mpd_response_finish(g_mpd)) {
lmc_failure();
return MPD_STATE_UNKNOWN;
}
return MPD_STATE_UNKNOWN;
}
if (!mpd_response_finish(g_mpd)) {
mpd_song_free(song);
lmc_failure();
return MPD_STATE_UNKNOWN;
}
*song_r = song;
return MPD_STATE_PLAY;
}
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;
}
char* getElapsedTime(Config* config, int status) {
if (!config->mpd_status) {
return strdup("");
}
unsigned time = mpd_status_get_elapsed_time(config->mpd_status);
return timeToString(config, time);
}
static unsigned
elapsed_percent(const struct mpd_status *status)
{
unsigned total = mpd_status_get_total_time(status);
if (total == 0)
return 0;
unsigned elapsed = mpd_status_get_elapsed_time(status);
if (elapsed >= total)
return 100;
return (elapsed * 100) / total;
}
static int
event_player(G_GNUC_UNUSED const struct mpd_connection *conn,
const struct mpd_song *song, const struct mpd_status *status)
{
enum mpd_state state;
g_assert(status != NULL);
state = mpd_status_get_state(status);
if (state == MPD_STATE_PAUSE) {
song_paused();
return MPDCRON_EVENT_SUCCESS;
}
else if (state != MPD_STATE_PLAY)
song_stopped();
if (was_paused) {
if (song != NULL && mpd_song_get_id(song) == last_id)
song_continued();
was_paused = false;
}
/* Submit the previous song */
if (prev != NULL && (song == NULL || mpd_song_get_id(prev) != mpd_song_get_id(song)))
song_ended(prev);
if (song != NULL) {
if (mpd_song_get_id(song) != last_id) {
/* New song. */
song_started(song);
last_id = mpd_song_get_id(song);
}
else {
/* still playing the previous song */
song_playing(song, mpd_status_get_elapsed_time(status));
}
}
if (prev != NULL) {
mpd_song_free(prev);
prev = NULL;
}
if (song != NULL) {
if ((prev = mpd_song_dup(song)) == NULL) {
g_critical("mpd_song_dup failed: out of memory");
return MPDCRON_EVENT_UNLOAD;
}
}
return MPDCRON_EVENT_SUCCESS;
}
static bool
setup_seek(struct mpdclient *c)
{
if (!mpdclient_is_playing(c))
return false;
if (seek_id != (int)mpd_status_get_song_id(c->status)) {
seek_id = mpd_status_get_song_id(c->status);
seek_target_time = mpd_status_get_elapsed_time(c->status);
}
schedule_seek_timer(c);
return true;
}
int
cmd_cdprev(gcc_unused int argc, gcc_unused char **argv,
struct mpd_connection *conn)
{
struct mpd_status *status = getStatus(conn);
/* go to previous track if mpd is playing first 3 seconds of
current track otherwise seek to beginning of current
track */
if (mpd_status_get_elapsed_time(status) < 3) {
cmd_prev(0, NULL, conn);
} else {
if (!mpd_run_seek_id(conn, mpd_status_get_song_id(status), 0))
printErrorAndExit(conn);
}
return 1;
}
char* getTimeBar(Config* config, int status) {
if (config->timebar < 3) {
return strdup("");
}
char* timeBar = calloc(config->timebar + 1, sizeof(char));
unsigned duration;
if (config->curr_song) {
duration = mpd_song_get_duration(config->curr_song);
} else {
duration = 0;
}
unsigned elapsed = mpd_status_get_elapsed_time(config->mpd_status);
unsigned blockSize = duration / (config->timebar - 2);
unsigned block = 0;
if (blockSize) {
block = elapsed / blockSize;
}
timeBar[0] = '[';
unsigned i;
for (i = 1; i < block; i++) {
timeBar[i] = '=';
}
if (i > config->timebar - 2) {
i = config->timebar - 2;
}
timeBar[i] = '>';
i++;
for (; i < config->timebar; i++) {
timeBar[i] = '-';
}
timeBar[config->timebar - 1] = ']';
timeBar[config->timebar] = 0;
return timeBar;
}
static void
update_progress_window(struct mpdclient *c, bool repaint)
{
unsigned elapsed, duration;
if (c->status == NULL)
elapsed = 0;
else if (seek_id >= 0 && seek_id == mpd_status_get_song_id(c->status))
elapsed = seek_target_time;
else
elapsed = mpd_status_get_elapsed_time(c->status);
duration = mpdclient_is_playing(c)
? mpd_status_get_total_time(c->status)
: 0;
if (progress_bar_set(&screen.progress_bar, elapsed, duration) ||
repaint)
progress_bar_paint(&screen.progress_bar);
}
void do_status(struct mpd_connection *con, int *current, unsigned int *current_elapsed, unsigned int *current_total, unsigned int *length, unsigned int *version)
{
struct mpd_status *st = mpd_run_status(con);
if (!st)
return;
if (check_error(con, NULL, false))
goto out;
switch (mpd_status_get_state(st)) {
case MPD_STATE_UNKNOWN:
case MPD_STATE_STOP:
if (current)
*current = -1;
if (current_elapsed)
*current_elapsed = 0;
if (current_total)
*current_total = 0;
break;
case MPD_STATE_PLAY:
case MPD_STATE_PAUSE:
if (current)
*current = mpd_status_get_song_pos(st);
if (current_elapsed)
*current_elapsed = mpd_status_get_elapsed_time(st);
if (current_total)
*current_total = mpd_status_get_total_time(st);
break;
}
if (length)
*length = mpd_status_get_queue_length(st);
if (version)
*version = mpd_status_get_queue_version(st);
out:
mpd_status_free(st);
}
void
updatempdstatus(void) {
char statustext[STEXTSIZE];
struct mpd_status *s = NULL;
struct mpd_song *so = NULL;
int s_volume,
s_flagmask,
s_queuelength,
s_songpos,
s_state,
s_songlen,
s_songtime;
int s_time_r, s_time_min, s_time_sec;
const char *artist, *title;
if(mpdcmd_connect() != 0)
return;
s = mpd_run_status(mpdc);
if(s == NULL)
return;
// retrieve status information
if((s_state = mpd_status_get_state(s)) == MPD_STATE_STOP ||
(so = mpd_run_current_song(mpdc)) == NULL)
goto EXIT;
s_volume = mpd_status_get_volume(s);
s_queuelength = mpd_status_get_queue_length(s);
s_songpos = mpd_status_get_song_pos(s);
s_songlen = mpd_status_get_total_time(s);
s_songtime = mpd_status_get_elapsed_time(s);
s_time_r = s_songlen - s_songtime;
s_time_sec = s_time_r % 60;
s_time_min = (s_time_r - s_time_sec) / 60;
if(mpd_status_get_consume(s) == 1)
s_flagmask |= MpdFlag_Consume;
if(mpd_status_get_single(s) == 1)
s_flagmask |= MpdFlag_Single;
if(mpd_status_get_random(s) == 1)
s_flagmask |= MpdFlag_Random;
if(mpd_status_get_repeat(s) == 1)
s_flagmask |= MpdFlag_Repeat;
artist = mpd_song_get_tag(so, MPD_TAG_ARTIST, 0);
title = mpd_song_get_tag(so, MPD_TAG_TITLE, 0);
//%artist - %title (-%total-%elapsed) [$flags] [#%pos/%queuelength]
snprintf(statustext, STEXTSIZE,
"%s - %s (-%d:%02d)",
artist != NULL ? artist : "名無し",
title != NULL ? title : "曲名無し",
s_time_min,
s_time_sec);
strncpy(stext, statustext, STEXTSIZE);
EXIT:;
mpd_song_free(so);
mpd_status_free(s);
return;
}
void mpd_query_status(struct mpd_connection *conn)
{
struct mpd_status *status;
struct mpd_song *song;
const struct mpd_audio_format *audio;
if (!conn)
return;
if (!mpd_command_list_begin(conn, true) ||
!mpd_send_status(conn) || !mpd_send_current_song(conn) || !mpd_command_list_end(conn)) {
mpd_printerror("queue_commands");
return;
}
status = mpd_recv_status(conn);
if (status == NULL) {
mpd_printerror("recv_status");
return;
}
if (currentSong != NULL) {
mpd_song_free(currentSong);
currentSong = NULL;
}
if (!mpd_response_next(conn)) {
mpd_printerror("response_next");
return;
}
song = mpd_recv_song(conn);
if (song != NULL) {
currentSong = mpd_song_dup(song);
mpd_song_free(song);
l_elapsedTimeSec = mpd_status_get_elapsed_time(status);
l_totalTimeSec = mpd_status_get_total_time(status);
l_bitRate = mpd_status_get_kbit_rate(status);
} else {
l_elapsedTimeSec = 0;
l_totalTimeSec = 0;
l_bitRate = 0;
}
l_state = mpd_status_get_state(status);
l_repeatEnabled = mpd_status_get_repeat(status);
l_randomEnabled = mpd_status_get_random(status);
l_singleEnabled = mpd_status_get_single(status);
l_consumeEnabled = mpd_status_get_consume(status);
l_volume = mpd_status_get_volume(status);
l_currentSongPos = mpd_status_get_song_pos(status) + 1;
l_playlistLength = mpd_status_get_queue_length(status);
audio = mpd_status_get_audio_format(status);
if (audio) {
l_sampleRate = audio->sample_rate;
l_channels = audio->channels;
} else {
l_sampleRate = 0;
l_channels = 0;
}
if (mpd_status_get_error(status) != NULL)
error("[MPD] query status : %s", charset_from_utf8(mpd_status_get_error(status)));
mpd_status_free(status);
if (!mpd_response_finish(conn)) {
mpd_printerror("response_finish");
return;
}
}
/* This function update the internal status tracking
* the MPD status. At then end, if the status has changed, a signal is emmited.
*/
void Player::updateStatus()
{
struct mpd_status *statusMpd;
EMSPlayerStatus statusEMS;
/* Get the status structure from MPD */
mpd_send_status(conn);
statusMpd = mpd_recv_status(conn);
if (statusMpd == NULL)
{
qCritical() << "Error while trying to get MPD status";
qCritical() << "Reconnecting...";
connectToMpd(); /* Reconnect */
return;
}
if (mpd_status_get_error(statusMpd) != NULL)
{
qCritical() << "MPD error: " << QString::fromUtf8(mpd_status_get_error(statusMpd));
}
if (!mpd_response_finish(conn))
{
qCritical() << "Error while trying to get MPD status" ;
qCritical() << "Reconnecting...";
connectToMpd();
return;
}
/* Fill the internal state from the answer */
switch (mpd_status_get_state(statusMpd))
{
case MPD_STATE_PAUSE:
statusEMS.state = STATUS_PAUSE;
break;
case MPD_STATE_PLAY:
statusEMS.state = STATUS_PLAY;
break;
case MPD_STATE_STOP:
statusEMS.state = STATUS_STOP;
break;
default:
statusEMS.state = STATUS_UNKNOWN;
break;
}
statusEMS.repeat = mpd_status_get_repeat(statusMpd);
statusEMS.random = mpd_status_get_random(statusMpd);
if (statusEMS.state == STATUS_PLAY || statusEMS.state == STATUS_PAUSE)
{
if (mpd_status_get_queue_length(statusMpd) != (unsigned int)playlist.tracks.size())
{
qCritical() << "Error: the playlist does not have the same size as the one used by MPD!";
/* We should not do this... */
removeAllTracks();
}
statusEMS.posInPlaylist = mpd_status_get_song_pos(statusMpd);
statusEMS.progress = mpd_status_get_elapsed_time(statusMpd);
}
mpd_status_free(statusMpd);
if (statusEMS.posInPlaylist != status.posInPlaylist ||
statusEMS.progress != status.progress ||
statusEMS.random != status.random ||
statusEMS.repeat != status.repeat ||
statusEMS.state != status.state )
{
mutex.lock();
status = statusEMS;
mutex.unlock();
emit statusChanged(statusEMS);
}
}
static void
env_export_status(struct mpd_status *status)
{
char *envstr;
const struct mpd_audio_format *fmt;
envstr = g_strdup_printf("%d", mpd_status_get_volume(status));
g_setenv("MPD_STATUS_VOLUME", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_repeat(status));
g_setenv("MPD_STATUS_REPEAT", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_random(status));
g_setenv("MPD_STATUS_RANDOM", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_single(status));
g_setenv("MPD_STATUS_SINGLE", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_consume(status));
g_setenv("MPD_STATUS_CONSUME", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_queue_length(status));
g_setenv("MPD_STATUS_QUEUE_LENGTH", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_queue_version(status));
g_setenv("MPD_STATUS_QUEUE_VERSION", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_crossfade(status));
g_setenv("MPD_STATUS_CROSSFADE", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_song_pos(status));
g_setenv("MPD_STATUS_SONG_POS", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%d", mpd_status_get_song_id(status));
g_setenv("MPD_STATUS_SONG_ID", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%u", mpd_status_get_elapsed_time(status));
g_setenv("MPD_STATUS_ELAPSED_TIME", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%u", mpd_status_get_elapsed_ms(status));
g_setenv("MPD_STATUS_ELAPSED_MS", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%u", mpd_status_get_total_time(status));
g_setenv("MPD_STATUS_TOTAL_TIME", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%u", mpd_status_get_kbit_rate(status));
g_setenv("MPD_STATUS_KBIT_RATE", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%u", mpd_status_get_update_id(status));
g_setenv("MPD_STATUS_UPDATE_ID", envstr, 1);
g_free(envstr);
g_setenv("MPD_STATUS_STATE", env_strstate(mpd_status_get_state(status)), 1);
if ((fmt = mpd_status_get_audio_format(status)) == NULL)
g_setenv("MPD_STATUS_AUDIO_FORMAT", "0", 1);
else {
g_setenv("MPD_STATUS_AUDIO_FORMAT", "1", 1);
envstr = g_strdup_printf("%u", fmt->sample_rate);
g_setenv("MPD_STATUS_AUDIO_FORMAT_SAMPLE_RATE", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%u", fmt->bits);
g_setenv("MPD_STATUS_AUDIO_FORMAT_BITS", envstr, 1);
g_free(envstr);
envstr = g_strdup_printf("%u", fmt->channels);
g_setenv("MPD_STATUS_AUDIO_FORMAT_CHANNELS", envstr, 1);
g_free(envstr);
}
}
void
CMPD::Update()
{
if(!_connected) {
iprintf("Reconnecting in 10 seconds.");
sleep(10);
if(Connect())
iprintf("%s", "Reconnected!");
else {
eprintf("%s", "Could not reconnect.");
return;
}
}
mpd_status *status = mpd_run_status(_conn);
mpd_stats *stats = mpd_run_stats(_conn);
if(status && stats) {
int newsongid = mpd_status_get_song_id(status);
int newsongpos = mpd_status_get_elapsed_time(status);
int curplaytime = mpd_stats_get_play_time(stats);
// new song
if(newsongid != _songid) {
_songid = newsongid;
_songpos = newsongpos;
_start = curplaytime;
mpd_song *song = mpd_run_current_song(_conn);
if(song) {
GotNewSong(song);
mpd_song_free(song);
}
}
// song playing
if(newsongpos != _songpos) {
_songpos = newsongpos;
CheckSubmit(curplaytime);
}
// check for client-to-client messages
if(mpd_send_read_messages(_conn)) {
mpd_message *msg;
while((msg = mpd_recv_message(_conn)) != NULL) {
const char *text = mpd_message_get_text(msg);
if(_gotsong && text && !strncmp(text, "love", 4))
AudioScrobbler->LoveTrack(_song);
mpd_message_free(msg);
}
mpd_response_finish(_conn);
}
mpd_status_free(status);
mpd_stats_free(stats);
}
else { // we have most likely lost our connection
eprintf("Could not query MPD server: %s", mpd_connection_get_error_message(_conn));
_connected = false;
}
}
void
basic_state_checking(void)
{
int rep, ran, sgl, len, crt, vol, ply, btr;
struct mpd_status *status;
status = getStatus(conn);
rep = mpd_status_get_repeat(status);
ran = mpd_status_get_random(status);
sgl = mpd_status_get_single(status);
len = mpd_status_get_queue_length(status);
crt = mpd_status_get_song_id(status);
vol = mpd_status_get_volume(status);
ply = mpd_status_get_state(status);
btr = mpd_status_get_kbit_rate(status);
basic_info->crt_time = mpd_status_get_elapsed_time(status);
basic_info->total_time = mpd_status_get_total_time(status);
mpd_status_free(status);
if(rep != basic_info->repeat || ran != basic_info->random
|| sgl != basic_info->single || len != basic_info->total
|| crt != basic_info->current || vol != basic_info->volume
|| ply != basic_info->state)
{
basic_info->repeat = rep;
basic_info->random = ran;
basic_info->single = sgl;
basic_info->total = len;
basic_info->current = crt;
basic_info->volume = vol;
basic_info->state = ply;
signal_all_wins();
}
/* as many songs's bit rate varies while playing
we refresh the bit rate display only when the
relevant change greater than 0.2 */
if(abs(basic_info->bit_rate - btr) / (float)(btr + 1) > 0.2)
{
basic_info->bit_rate = btr;
signal_win(BASIC_INFO);
}
/* get current song's name */
status = init_mpd_status(conn);
strncpy(basic_info->format, "null", 16);
*basic_info->crt_name = '\0';
if (basic_info->state == MPD_STATE_PLAY ||
basic_info->state == MPD_STATE_PAUSE) {
struct mpd_song *song;
if (!mpd_response_next(conn))
printErrorAndExit(conn);
song = mpd_recv_song(conn);
if (song != NULL) {
strncpy(basic_info->crt_name, get_song_tag(song, MPD_TAG_TITLE), 512);
strncpy(basic_info->format, get_song_format(song), 16);
}
mpd_song_free(song);
}
mpd_status_free(status);
my_finishCommand(conn);
}
void
print_status(struct mpd_connection *conn)
{
if (!mpd_command_list_begin(conn, true) ||
!mpd_send_status(conn) ||
!mpd_send_current_song(conn) ||
!mpd_command_list_end(conn))
printErrorAndExit(conn);
struct mpd_status *status = mpd_recv_status(conn);
if (status == NULL)
printErrorAndExit(conn);
if (mpd_status_get_state(status) == MPD_STATE_PLAY ||
mpd_status_get_state(status) == MPD_STATE_PAUSE) {
if (!mpd_response_next(conn))
printErrorAndExit(conn);
struct mpd_song *song = mpd_recv_song(conn);
if (song != NULL) {
pretty_print_song(song);
printf("\n");
mpd_song_free(song);
}
if (mpd_status_get_state(status) == MPD_STATE_PLAY)
printf("[playing]");
else
printf("[paused] ");
printf(" #%i/%u %3i:%02i/%i:%02i (%u%%)\n",
mpd_status_get_song_pos(status) + 1,
mpd_status_get_queue_length(status),
mpd_status_get_elapsed_time(status) / 60,
mpd_status_get_elapsed_time(status) % 60,
mpd_status_get_total_time(status) / 60,
mpd_status_get_total_time(status) % 60,
elapsed_percent(status));
}
if (mpd_status_get_update_id(status) > 0)
printf("Updating DB (#%u) ...\n",
mpd_status_get_update_id(status));
if (mpd_status_get_volume(status) >= 0)
printf("volume:%3i%c ", mpd_status_get_volume(status), '%');
else {
printf("volume: n/a ");
}
printf("repeat: ");
if (mpd_status_get_repeat(status))
printf("on ");
else printf("off ");
printf("random: ");
if (mpd_status_get_random(status))
printf("on ");
else printf("off ");
printf("single: ");
if (mpd_status_get_single(status))
printf("on ");
else printf("off ");
printf("consume: ");
if (mpd_status_get_consume(status))
printf("on \n");
else printf("off\n");
if (mpd_status_get_error(status) != NULL)
printf("ERROR: %s\n",
charset_from_utf8(mpd_status_get_error(status)));
mpd_status_free(status);
if (!mpd_response_finish(conn))
printErrorAndExit(conn);
}
static int lmpdstatus_index(lua_State *L)
{
const char *key;
const struct mpd_audio_format *audio_format;
struct mpd_status **status;
status = luaL_checkudata(L, 1, MPD_STATUS_T);
key = luaL_checkstring(L, 2);
assert(*status != NULL);
if (strncmp(key, "volume", 7) == 0) {
lua_pushinteger(L, mpd_status_get_volume(*status));
return 1;
}
else if (strncmp(key, "repeat", 7) == 0) {
lua_pushinteger(L, mpd_status_get_repeat(*status));
return 1;
}
else if (strncmp(key, "random", 7) == 0) {
lua_pushinteger(L, mpd_status_get_random(*status));
return 1;
}
else if (strncmp(key, "single", 7) == 0) {
lua_pushinteger(L, mpd_status_get_single(*status));
return 1;
}
else if (strncmp(key, "consume", 8) == 0) {
lua_pushinteger(L, mpd_status_get_consume(*status));
return 1;
}
else if (strncmp(key, "queue_length", 16) == 0) {
lua_pushnumber(L, mpd_status_get_queue_length(*status));
return 1;
}
else if (strncmp(key, "queue_version", 17) == 0) {
lua_pushnumber(L, mpd_status_get_queue_version(*status));
return 1;
}
else if (strncmp(key, "state", 6) == 0) {
lua_pushinteger(L, mpd_status_get_state(*status));
return 1;
}
else if (strncmp(key, "crossfade", 10) == 0) {
lua_pushinteger(L, mpd_status_get_crossfade(*status));
return 1;
}
else if (strncmp(key, "song_pos", 5) == 0) {
lua_pushinteger(L, mpd_status_get_song_pos(*status));
return 1;
}
else if (strncmp(key, "song_id", 7) == 0) {
lua_pushinteger(L, mpd_status_get_song_id(*status));
return 1;
}
else if (strncmp(key, "elapsed_time", 13) == 0) {
lua_pushinteger(L, mpd_status_get_elapsed_time(*status));
return 1;
}
else if (strncmp(key, "total_time", 11) == 0) {
lua_pushinteger(L, mpd_status_get_total_time(*status));
return 1;
}
else if (strncmp(key, "kbit_rate", 10) == 0) {
lua_pushinteger(L, mpd_status_get_kbit_rate(*status));
return 1;
}
else if (strncmp(key, "audio_format", 13) == 0) {
audio_format = mpd_status_get_audio_format(*status);
lua_newtable(L);
lua_pushinteger(L, audio_format->sample_rate);
lua_setfield(L, -2, "sample_rate");
lua_pushinteger(L, audio_format->bits);
lua_setfield(L, -2, "bits");
lua_pushinteger(L, audio_format->channels);
lua_setfield(L, -2, "channels");
return 1;
}
else if (strncmp(key, "update_id", 11) == 0) {
lua_pushinteger(L, mpd_status_get_update_id(*status));
return 1;
}
else if (strncmp(key, "error", 6) == 0) {
lua_pushstring(L, mpd_status_get_error(*status));
return 1;
}
else
return luaL_error(L, "Invalid key `%s'", key);
}
int main(int argc, char ** argv) {
struct mpd_connection *conn;
conn = mpd_connection_new(NULL, 0, 30000);
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS)
return handle_error(conn);
{
int i;
for(i=0;i<3;i++) {
printf("version[%i]: %i\n",i,
mpd_connection_get_server_version(conn)[i]);
}
}
if(argc==1) {
struct mpd_status * status;
struct mpd_song *song;
const struct mpd_audio_format *audio_format;
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 (status == NULL)
return handle_error(conn);
printf("volume: %i\n", mpd_status_get_volume(status));
printf("repeat: %i\n", mpd_status_get_repeat(status));
printf("queue version: %u\n", mpd_status_get_queue_version(status));
printf("queue length: %i\n", mpd_status_get_queue_length(status));
if (mpd_status_get_error(status) != NULL)
printf("error: %s\n", mpd_status_get_error(status));
if (mpd_status_get_state(status) == MPD_STATE_PLAY ||
mpd_status_get_state(status) == MPD_STATE_PAUSE) {
printf("song: %i\n", mpd_status_get_song_pos(status));
printf("elaspedTime: %i\n",mpd_status_get_elapsed_time(status));
printf("elasped_ms: %u\n", mpd_status_get_elapsed_ms(status));
printf("totalTime: %i\n", mpd_status_get_total_time(status));
printf("bitRate: %i\n", mpd_status_get_kbit_rate(status));
}
audio_format = mpd_status_get_audio_format(status);
if (audio_format != NULL) {
printf("sampleRate: %i\n", audio_format->sample_rate);
printf("bits: %i\n", audio_format->bits);
printf("channels: %i\n", audio_format->channels);
}
mpd_status_free(status);
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS)
return handle_error(conn);
mpd_response_next(conn);
while ((song = mpd_recv_song(conn)) != NULL) {
printf("uri: %s\n", mpd_song_get_uri(song));
print_tag(song, MPD_TAG_ARTIST, "artist");
print_tag(song, MPD_TAG_ALBUM, "album");
print_tag(song, MPD_TAG_TITLE, "title");
print_tag(song, MPD_TAG_TRACK, "track");
print_tag(song, MPD_TAG_NAME, "name");
print_tag(song, MPD_TAG_DATE, "date");
if (mpd_song_get_duration(song) > 0) {
printf("time: %u\n", mpd_song_get_duration(song));
}
printf("pos: %u\n", mpd_song_get_pos(song));
mpd_song_free(song);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
}
else if(argc==3 && strcmp(argv[1],"lsinfo")==0) {
struct mpd_entity * entity;
if (!mpd_send_list_meta(conn, argv[2]))
return handle_error(conn);
while ((entity = mpd_recv_entity(conn)) != NULL) {
const struct mpd_song *song;
const struct mpd_directory *dir;
const struct mpd_playlist *pl;
switch (mpd_entity_get_type(entity)) {
case MPD_ENTITY_TYPE_UNKNOWN:
break;
case MPD_ENTITY_TYPE_SONG:
song = mpd_entity_get_song(entity);
printf("uri: %s\n", mpd_song_get_uri(song));
print_tag(song, MPD_TAG_ARTIST, "artist");
print_tag(song, MPD_TAG_ALBUM, "album");
print_tag(song, MPD_TAG_TITLE, "title");
print_tag(song, MPD_TAG_TRACK, "track");
break;
case MPD_ENTITY_TYPE_DIRECTORY:
dir = mpd_entity_get_directory(entity);
printf("directory: %s\n", mpd_directory_get_path(dir));
break;
case MPD_ENTITY_TYPE_PLAYLIST:
pl = mpd_entity_get_playlist(entity);
printf("playlist: %s\n",
mpd_playlist_get_path(pl));
break;
}
mpd_entity_free(entity);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
}
else if(argc==2 && strcmp(argv[1],"artists")==0) {
struct mpd_pair *pair;
if (!mpd_search_db_tags(conn, MPD_TAG_ARTIST) ||
!mpd_search_commit(conn))
return handle_error(conn);
while ((pair = mpd_recv_pair_tag(conn,
MPD_TAG_ARTIST)) != NULL) {
printf("%s\n", pair->value);
mpd_return_pair(conn, pair);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
} else if (argc == 2 && strcmp(argv[1], "playlists") == 0) {
if (!mpd_send_list_playlists(conn))
return handle_error(conn);
struct mpd_playlist *playlist;
while ((playlist = mpd_recv_playlist(conn)) != NULL) {
printf("%s\n",
mpd_playlist_get_path(playlist));
mpd_playlist_free(playlist);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
} else if (argc == 2 && strcmp(argv[1], "idle") == 0) {
enum mpd_idle idle = mpd_run_idle(conn);
if (idle == 0 &&
mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS)
return handle_error(conn);
for (unsigned j = 0;; ++j) {
enum mpd_idle i = 1 << j;
const char *name = mpd_idle_name(i);
if (name == NULL)
break;
if (idle & i)
printf("%s\n", name);
}
} else if (argc == 3 && strcmp(argv[1], "subscribe") == 0) {
/* subscribe to a channel and print all messages */
if (!mpd_run_subscribe(conn, argv[2]))
return handle_error(conn);
while (mpd_run_idle_mask(conn, MPD_IDLE_MESSAGE) != 0) {
if (!mpd_send_read_messages(conn))
return handle_error(conn);
struct mpd_message *msg;
while ((msg = mpd_recv_message(conn)) != NULL) {
printf("%s\n", mpd_message_get_text(msg));
mpd_message_free(msg);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
}
return handle_error(conn);
} else if (argc == 2 && strcmp(argv[1], "channels") == 0) {
/* print a list of channels */
if (!mpd_send_channels(conn))
return handle_error(conn);
struct mpd_pair *pair;
while ((pair = mpd_recv_channel_pair(conn)) != NULL) {
printf("%s\n", pair->value);
mpd_return_pair(conn, pair);
}
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS ||
!mpd_response_finish(conn))
return handle_error(conn);
} else if (argc == 4 && strcmp(argv[1], "message") == 0) {
/* send a message to a channel */
if (!mpd_run_send_message(conn, argv[2], argv[3]))
return handle_error(conn);
}
mpd_connection_free(conn);
return 0;
}
/*
* pgmpc_status
*
* Show current song and status.
*/
Datum
pgmpc_status(PG_FUNCTION_ARGS)
{
#define PGMPC_STATUS_COLUMNS 7
Datum values[PGMPC_STATUS_COLUMNS];
bool nulls[PGMPC_STATUS_COLUMNS];
TupleDesc tupdesc;
HeapTuple tuple;
Datum result;
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
pgmpc_init();
/* Initialize the values of return tuple */
MemSet(values, 0, sizeof(values));
MemSet(nulls, true, sizeof(nulls));
/*
* Send all necessary commands at once to avoid unnecessary round
* trips. The following information is obtained in an aync way:
* - current status of server
* - current song run on server
*/
if (!mpd_command_list_begin(mpd_conn, true) ||
!mpd_send_status(mpd_conn) ||
!mpd_send_current_song(mpd_conn) ||
!mpd_command_list_end(mpd_conn))
pgmpc_print_error();
/* Obtain status from server and check it */
mpd_status = mpd_recv_status(mpd_conn);
if (mpd_status == NULL)
pgmpc_print_error();
/* Show current song if any */
if (mpd_status_get_state(mpd_status) == MPD_STATE_PLAY ||
mpd_status_get_state(mpd_status) == MPD_STATE_PAUSE)
{
struct mpd_song *song;
/* There should be a next response, in this case a song */
if (!mpd_response_next(mpd_conn))
pgmpc_print_error();
/* And now get it */
song = mpd_recv_song(mpd_conn);
if (song != NULL)
{
/* Get information about the current song */
const char *title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
const char *artist = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);
const char *album = mpd_song_get_tag(song, MPD_TAG_ALBUM, 0);
unsigned int elapsed_time = mpd_status_get_elapsed_time(mpd_status);
unsigned int total_time = mpd_status_get_total_time(mpd_status);
int song_pos = mpd_status_get_song_pos(mpd_status) + 1;
int volume = mpd_status_get_volume(mpd_status);
/* Build tuple using this information */
if (title)
{
nulls[0] = false;
values[0] = CStringGetTextDatum(title);
}
else
nulls[0] = true;
if (artist)
{
nulls[1] = false;
values[1] = CStringGetTextDatum(artist);
}
else
nulls[1] = true;
if (album)
{
nulls[2] = false;
values[2] = CStringGetTextDatum(album);
}
else
nulls[2] = true;
nulls[3] = false;
values[3] = UInt32GetDatum(elapsed_time);
nulls[4] = false;
values[4] = UInt32GetDatum(total_time);
nulls[5] = false;
values[5] = Int32GetDatum(song_pos);
nulls[6] = false;
values[6] = Int32GetDatum(volume);
/* Song data is no more needed */
mpd_song_free(song);
}
if (!mpd_response_finish(mpd_conn))
pgmpc_print_error();
}
/* Cleanup MPD status */
pgmpc_reset();
/* Form result and return it */
tuple = heap_form_tuple(tupdesc, values, nulls);
result = HeapTupleGetDatum(tuple);
PG_RETURN_DATUM(result);
}
int
cmd_seek(gcc_unused int argc, gcc_unused char **argv,
struct mpd_connection *conn)
{
struct mpd_status *status;
char * arg = argv[0];
int seekchange;
int total_secs;
int rel = 0;
status = getStatus(conn);
if (mpd_status_get_state(status) == MPD_STATE_STOP)
DIE("not currently playing\n");
/* Detect +/- if exists point to the next char */
if (*arg == '+')
rel = 1;
else if (*arg == '-')
rel = -1;
if (rel != 0)
++arg;
/* If seeking by percent */
if (arg[strlen(arg) - 1] == '%') {
/* Remove the % */
arg[strlen(arg) - 1] = '\0';
/* percent seek, strtod is needed for percent with decimals */
char *test;
double perc = strtod(arg,&test);
if (*test != '\0' || (rel == 0 && (perc < 0 || perc > 100)) ||
(rel && perc > abs(100)))
DIE("\"%s\" is not an number between 0 and 100\n", arg);
seekchange = perc * mpd_status_get_total_time(status) / 100 + 0.5;
} else { /* If seeking by absolute seek time */
if (strchr(arg, ':') != NULL) {
int hr = 0;
int min = 0;
int sec = 0;
/* Take the seconds off the end of arg */
char *sec_ptr = strrchr(arg, ':');
/* Remove ':' and move the pointer one byte up */
*sec_ptr = '\0';
++sec_ptr;
/* If hour is in the argument, else just point to the arg */
char *min_ptr = strrchr(arg, ':');
if (min_ptr != NULL) {
/* Remove ':' and move the pointer one byte up */
*min_ptr = '\0';
++min_ptr;
/* If the argument still exists, it's the hour */
if (arg != NULL) {
char *hr_ptr = arg;
char *test;
hr = strtol(hr_ptr, &test, 10);
if (*test != '\0' ||
(rel == 0 && hr < 0))
DIE("\"%s\" is not a positive number\n", sec_ptr);
}
} else {
min_ptr = arg;
}
/* Change the pointers to a integer */
char *test;
sec = strtol(sec_ptr, &test, 10);
if (*test != '\0' || (rel == 0 && sec < 0))
DIE("\"%s\" is not a positive number\n", sec_ptr);
min = strtol( min_ptr, &test, 10 );
if( *test != '\0' || (rel == 0 && min < 0 ))
DIE("\"%s\" is not a positive number\n", min_ptr);
/* If mins exist, check secs. If hrs exist, check mins */
if (min && strlen(sec_ptr) != 2)
DIE("\"%s\" is not two digits\n", sec_ptr);
else if (hr && strlen(min_ptr) != 2)
DIE("\"%s\" is not two digits\n", min_ptr);
/* Finally, make sure they're not above 60 if higher unit exists */
if (min && sec > 60)
DIE("\"%s\" is greater than 60\n", sec_ptr);
else if (hr && min > 60 )
DIE("\"%s\" is greater than 60\n", min_ptr);
total_secs = (hr * 3600) + (min * 60) + sec;
} else {
/* absolute seek (in seconds) */
char *test;
total_secs = strtol(arg, &test, 10); /* get the # of seconds */
if (*test != '\0' || (rel == 0 && total_secs < 0))
DIE("\"%s\" is not a positive number\n", arg);
}
seekchange = total_secs;
}
/* This detects +/- and is necessary due to the parsing of HH:MM:SS numbers*/
int seekto;
if (rel == 1)
seekto = mpd_status_get_elapsed_time(status) + seekchange;
else if (rel == -1)
seekto = mpd_status_get_elapsed_time(status) - seekchange;
else
seekto = seekchange;
if (seekto > (int)mpd_status_get_total_time(status))
DIE("Seek amount would seek past the end of the song\n");
if (!mpd_run_seek_id(conn, mpd_status_get_song_id(status), seekto))
printErrorAndExit(conn);
mpd_status_free(status);
return 1;
}