void mpd_change_volume(int val)
{
int volume = mpd.volume + val;
if (volume > 100)
volume = 100;
if (volume < 0)
volume = 0;
mpd_run_set_volume(mpd.conn, volume);
}
void
changeVolume(void *val)
{
struct mpd_connection *con = (struct mpd_connection *)val;
printf("Change volume to %d on connection : %p\n", volume, con);
sleep(1);
if (!mpd_run_set_volume(con, volume++))
printf("Failed to change volume\n");
}
int
cmd_volume(int argc, char **argv, struct mpd_connection *conn)
{
struct int_value_change ch;
if (argc == 1) {
if (!parse_int_value_change(argv[0], &ch))
DIE("\"%s\" is not an integer\n", argv[0]);
} else {
struct mpd_status *status = getStatus(conn);
if (mpd_status_get_volume(status) >= 0)
printf("volume:%3i%c\n",
mpd_status_get_volume(status), '%');
else
printf("volume: n/a\n");
mpd_status_free(status);
return 0;
}
if (ch.is_relative) {
#if LIBMPDCLIENT_CHECK_VERSION(2,9,0)
if (mpd_connection_cmp_server_version(conn, 0, 18, 0) >= 0) {
/* MPD 0.18 knows the "volume" command for
relative changes */
if (!mpd_run_change_volume(conn, ch.value))
printErrorAndExit(conn);
return 1;
}
#endif
struct mpd_status *status = getStatus(conn);
int old_volume = mpd_status_get_volume(status);
mpd_status_free(status);
ch.value += old_volume;
if (ch.value < 0)
ch.value = 0;
else if (ch.value > 100)
ch.value = 100;
if (ch.value == old_volume)
return 1;
}
if (!mpd_run_set_volume(conn, ch.value))
printErrorAndExit(conn);
return 1;
}
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");
}
}
}
/*
* Set the volume to an integer between 0 and 100.
*
* Return true on success, false on failure.
*/
bool
Control::setvolume(int vol)
{
if (vol < 0) {
vol = 0;
} else if (vol > 100) {
vol = 100;
}
EXIT_IDLE;
pms->log(MSG_DEBUG, 0, "Setting volume to %d%%\n", vol);
return mpd_run_set_volume(conn->h(), vol);
}
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");
}
}
}
/*
* pgmpc_set_volume
* Set volume on server.
*/
Datum
pgmpc_set_volume(PG_FUNCTION_ARGS)
{
unsigned int volume = PG_GETARG_UINT32(0);
/* Check for incorrect values */
if (volume > 100)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("Volume value needs to be between 0 and 100")));
/* Run the command */
pgmpc_init();
if (!mpd_run_set_volume(mpd_conn, volume))
pgmpc_print_error();
pgmpc_reset();
PG_RETURN_VOID();
}
int volume_update() {
int targetVolume, setVolumeTo = -1;
if (DEBUG > 1)
fprintf (stderr, "DEBUG: [mgr-thread] update volume\n");
if (flag_start || flag_stop || flag_warmingup || cur_mpd_player_status == MPD_STATE_PLAY) {
// fetch user volume
ADC_updateVolume();
targetVolume = ADC_getVolume();
ADC_ResetFlags();
if (targetVolume < 0) {
fprintf(stderr, "ERROR: ADC WRAPPER: incorrect ADC volume received: %d\n", targetVolume);
return 0;
}
if (flag_stop)
targetVolume = 0;
setVolumeTo = volume_next_step(targetVolume);
} else {
if (cur_mpd_volume > 0)
setVolumeTo = 0;
}
if (conn && setVolumeTo != -1) {
if (!mpd_run_set_volume(conn, setVolumeTo)) {
printf("DEBUG: ADC: set volume failed\n");
return 0;
}
cur_mpd_volume = setVolumeTo;
if (DEBUG)
fprintf(stderr, "DEBUG: ADC WRAPPER: set volume to %d (target %d)\n", setVolumeTo, targetVolume);
}
return 1;
}
int cmd_volume ( int argc, char ** argv, struct mpd_connection *conn )
{
struct int_value_change ch;
struct mpd_status *status;
if(argc==1) {
if(!parse_int_value_change(argv[0], &ch))
DIE("\"%s\" is not an integer\n", argv[0]);
} else {
status = getStatus(conn);
if (mpd_status_get_volume(status) >= 0)
printf("volume:%3i%c\n",
mpd_status_get_volume(status), '%');
else
printf("volume: n/a\n");
mpd_status_free(status);
return 0;
}
if (ch.is_relative) {
int old_volume;
status = getStatus(conn);
old_volume = mpd_status_get_volume(status);
mpd_status_free(status);
ch.value += old_volume;
if (ch.value < 0)
ch.value = 0;
else if (ch.value > 100)
ch.value = 100;
if (ch.value == old_volume)
return 1;
}
if (!mpd_run_set_volume(conn, ch.value))
printErrorAndExit(conn);
return 1;
}
int callback_mpd(struct mg_connection *c)
{
enum mpd_cmd_ids cmd_id = get_cmd_id(c->content);
size_t n = 0;
unsigned int uint_buf, uint_buf_2;
int int_buf;
char *p_charbuf = NULL, *token;
if(cmd_id == -1)
return MG_TRUE;
if(mpd.conn_state != MPD_CONNECTED && cmd_id != MPD_API_SET_MPDHOST &&
cmd_id != MPD_API_GET_MPDHOST && cmd_id != MPD_API_SET_MPDPASS &&
cmd_id != MPD_API_GET_DIRBLEAPITOKEN)
return MG_TRUE;
switch(cmd_id)
{
case MPD_API_UPDATE_DB:
mpd_run_update(mpd.conn, NULL);
break;
case MPD_API_SET_PAUSE:
mpd_run_toggle_pause(mpd.conn);
break;
case MPD_API_SET_PREV:
mpd_run_previous(mpd.conn);
break;
case MPD_API_SET_NEXT:
mpd_run_next(mpd.conn);
break;
case MPD_API_SET_PLAY:
mpd_run_play(mpd.conn);
break;
case MPD_API_SET_STOP:
mpd_run_stop(mpd.conn);
break;
case MPD_API_RM_ALL:
mpd_run_clear(mpd.conn);
break;
case MPD_API_RM_TRACK:
if(sscanf(c->content, "MPD_API_RM_TRACK,%u", &uint_buf))
mpd_run_delete_id(mpd.conn, uint_buf);
break;
case MPD_API_PLAY_TRACK:
if(sscanf(c->content, "MPD_API_PLAY_TRACK,%u", &uint_buf))
mpd_run_play_id(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_RANDOM:
if(sscanf(c->content, "MPD_API_TOGGLE_RANDOM,%u", &uint_buf))
mpd_run_random(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_REPEAT:
if(sscanf(c->content, "MPD_API_TOGGLE_REPEAT,%u", &uint_buf))
mpd_run_repeat(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_CONSUME:
if(sscanf(c->content, "MPD_API_TOGGLE_CONSUME,%u", &uint_buf))
mpd_run_consume(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_SINGLE:
if(sscanf(c->content, "MPD_API_TOGGLE_SINGLE,%u", &uint_buf))
mpd_run_single(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_CROSSFADE:
if(sscanf(c->content, "MPD_API_TOGGLE_CROSSFADE,%u", &uint_buf))
mpd_run_crossfade(mpd.conn, uint_buf);
break;
case MPD_API_GET_OUTPUTS:
mpd.buf_size = mpd_put_outputs(mpd.buf, 1);
c->callback_param = NULL;
mpd_notify_callback(c, MG_POLL);
break;
case MPD_API_TOGGLE_OUTPUT:
if (sscanf(c->content, "MPD_API_TOGGLE_OUTPUT,%u,%u", &uint_buf, &uint_buf_2)) {
if (uint_buf_2)
mpd_run_enable_output(mpd.conn, uint_buf);
else
mpd_run_disable_output(mpd.conn, uint_buf);
}
break;
case MPD_API_SET_VOLUME:
if(sscanf(c->content, "MPD_API_SET_VOLUME,%ud", &uint_buf) && uint_buf <= 100)
mpd_run_set_volume(mpd.conn, uint_buf);
break;
case MPD_API_SET_SEEK:
if(sscanf(c->content, "MPD_API_SET_SEEK,%u,%u", &uint_buf, &uint_buf_2))
mpd_run_seek_id(mpd.conn, uint_buf, uint_buf_2);
break;
case MPD_API_GET_QUEUE:
if(sscanf(c->content, "MPD_API_GET_QUEUE,%u", &uint_buf))
n = mpd_put_queue(mpd.buf, uint_buf);
break;
case MPD_API_GET_BROWSE:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_GET_BROWSE"))
goto out_browse;
uint_buf = strtoul(strtok(NULL, ","), NULL, 10);
if((token = strtok(NULL, ",")) == NULL)
goto out_browse;
free(p_charbuf);
p_charbuf = strdup(c->content);
n = mpd_put_browse(mpd.buf, get_arg2(p_charbuf), uint_buf);
out_browse:
free(p_charbuf);
break;
case MPD_API_ADD_TRACK:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_ADD_TRACK"))
goto out_add_track;
if((token = strtok(NULL, ",")) == NULL)
goto out_add_track;
free(p_charbuf);
p_charbuf = strdup(c->content);
mpd_run_add(mpd.conn, get_arg1(p_charbuf));
out_add_track:
free(p_charbuf);
break;
case MPD_API_ADD_PLAY_TRACK:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_ADD_PLAY_TRACK"))
goto out_play_track;
if((token = strtok(NULL, ",")) == NULL)
goto out_play_track;
free(p_charbuf);
p_charbuf = strdup(c->content);
int_buf = mpd_run_add_id(mpd.conn, get_arg1(p_charbuf));
if(int_buf != -1)
mpd_run_play_id(mpd.conn, int_buf);
out_play_track:
free(p_charbuf);
break;
case MPD_API_ADD_PLAYLIST:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_ADD_PLAYLIST"))
goto out_playlist;
if((token = strtok(NULL, ",")) == NULL)
goto out_playlist;
free(p_charbuf);
p_charbuf = strdup(c->content);
mpd_run_load(mpd.conn, get_arg1(p_charbuf));
out_playlist:
free(p_charbuf);
break;
case MPD_API_SAVE_QUEUE:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_SAVE_QUEUE"))
goto out_save_queue;
if((token = strtok(NULL, ",")) == NULL)
goto out_save_queue;
free(p_charbuf);
p_charbuf = strdup(c->content);
mpd_run_save(mpd.conn, get_arg1(p_charbuf));
out_save_queue:
free(p_charbuf);
break;
case MPD_API_SEARCH:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_SEARCH"))
goto out_search;
if((token = strtok(NULL, ",")) == NULL)
goto out_search;
free(p_charbuf);
p_charbuf = strdup(c->content);
n = mpd_search(mpd.buf, get_arg1(p_charbuf));
out_search:
free(p_charbuf);
break;
#ifdef WITH_MPD_HOST_CHANGE
/* Commands allowed when disconnected from MPD server */
case MPD_API_SET_MPDHOST:
int_buf = 0;
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_SET_MPDHOST"))
goto out_host_change;
if((int_buf = strtol(strtok(NULL, ","), NULL, 10)) <= 0)
goto out_host_change;
if((token = strtok(NULL, ",")) == NULL)
goto out_host_change;
strncpy(mpd.host, token, sizeof(mpd.host));
mpd.port = int_buf;
mpd.conn_state = MPD_RECONNECT;
free(p_charbuf);
return MG_TRUE;
out_host_change:
free(p_charbuf);
break;
case MPD_API_GET_MPDHOST:
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"mpdhost\", \"data\": "
"{\"host\" : \"%s\", \"port\": \"%d\", \"passwort_set\": %s}"
"}", mpd.host, mpd.port, mpd.password ? "true" : "false");
break;
case MPD_API_GET_DIRBLEAPITOKEN:
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"dirbleapitoken\", \""
"data\": \"%s\"}", dirble_api_token);
break;
case MPD_API_SET_MPDPASS:
p_charbuf = strdup(c->content);
if(strcmp(strtok(p_charbuf, ","), "MPD_API_SET_MPDPASS"))
goto out_set_pass;
if((token = strtok(NULL, ",")) == NULL)
goto out_set_pass;
if(mpd.password)
free(mpd.password);
mpd.password = strdup(token);
mpd.conn_state = MPD_RECONNECT;
free(p_charbuf);
return MG_TRUE;
out_set_pass:
free(p_charbuf);
break;
#endif
}
if(mpd.conn_state == MPD_CONNECTED && mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS)
{
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"error\", \"data\": \"%s\"}",
mpd_connection_get_error_message(mpd.conn));
/* Try to recover error */
if (!mpd_connection_clear_error(mpd.conn))
mpd.conn_state = MPD_FAILURE;
}
if(n > 0)
mg_websocket_write(c, 1, mpd.buf, n);
return MG_TRUE;
}
void Connection::SetVolume(unsigned vol)
{
prechecksNoCommandsList();
mpd_run_set_volume(m_connection.get(), vol);
checkErrors();
}
void* threadManager(void *thread_arg){
int i;
conn = NULL;
if (DEBUG)
fprintf (stderr, "DEBUG: [mgr-thread] -starting\n");
alsaSetup();
if (ADC_init() < 0) {
fprintf(stderr, "FATAL: ADC: Unable to setup ADC interface\n");
flag_exit++;
return thread_arg;
}
for (i = 0; i < 10 && conn == NULL; i++) {
if (!mgr_mpd_connect()) {
fprintf(stderr, "ERROR: MPD: Unable to connect, reconnecting...\n");
delay(1000);
}
}
if (conn == NULL) {
fprintf(stderr, "FATAL: MPD: Unable to connect to MPD server, exiting...\n");
flag_exit++;
return thread_arg;
}
if (!mgr_mpd_fetch_status( conn, 1 )) {
fprintf(stderr, "ERROR: MPD: Unable to fetch MPD status\n");
mgr_handle_mpd_error();
}
// Read ADC & Update MPD
volume_update();
// Set volume to 0 if it does not play
if (conn != NULL && cur_mpd_player_status != MPD_STATE_PLAY) {
if (DEBUG)
fprintf (stderr, "DEBUG: [mgr-thread] mpd: starting playing...\n");
// set value to 0
if (!mpd_run_set_volume(conn, 0)) {
fprintf(stderr, "ERROR: MPD: Unable to set volume\n");
mgr_handle_mpd_error();
}
// start player
if (!mpd_run_play(conn)) {
fprintf(stderr, "ERROR: MPD: Unable to start playing\n");
mgr_handle_mpd_error();
}
}
mgr_unsetWarmingUp();
if (DEBUG)
fprintf (stderr, "DEBUG: [mgr-thread] +started\n");
while (!flag_exit) {
//////////////////////////////////////////////////////////////////
// Open MPD Connection
//////////////////////////////////////////////////////////////////
if (conn == NULL) {
if (!mgr_mpd_connect()) {
delay(5000);
continue;
}
}
//////////////////////////////////////////////////////////////////
// WARMING?
//////////////////////////////////////////////////////////////////
if (mgr_isWarmingUp()) {
delay(1000);
continue;
}
//////////////////////////////////////////////////////////////////
// RECEIVE STATUS
//////////////////////////////////////////////////////////////////
if (!mgr_mpd_fetch_status( conn, 0 )) {
mgr_handle_mpd_error();
continue;
}
//////////////////////////////////////////////////////////////////
// update volume
//////////////////////////////////////////////////////////////////
volume_update();
//////////////////////////////////////////////////////////////////
// update playlist if needed
//////////////////////////////////////////////////////////////////
if (cur_mpd_stats_number_of_songs != cur_mpd_status_queue_len) {
if (!mqr_update_playlist()) {
fprintf(stderr, "ERROR: MPD: Unable to update playlist\n");
mgr_handle_mpd_error();
return 0;
}
}
//////////////////////////////////////////////////////////////////
// check player timeout
//////////////////////////////////////////////////////////////////
if (cur_mpd_player_status == MPD_STATE_PLAY) {
if (ts_started == 0)
ts_started = time(NULL);
int timeout = 3600;
if (ts_started + timeout < time(NULL)) {
if (!flag_stop) {
if (DEBUG)
fprintf(stderr, "DEBUG: MGR: Timeout reached, stop playing\n");
}
flag_stop++;
}
} else {
ts_started = 0;
}
//////////////////////////////////////////////////////////////////
// START
//////////////////////////////////////////////////////////////////
if (flag_start) {
alsaPlaySound(PCM_SOUND_ID_CLICK);
if (!mpd_run_play(conn)) {
fprintf(stderr, "ERROR: [mgr-thread] mpd: start command failed\n");
mgr_handle_mpd_error();
continue;
}
if (DEBUG)
fprintf(stderr, "DEBUG: [mgr-thread] player started\n");
cur_mpd_player_status = MPD_STATE_PLAY; // for volume control
flag_start = 0;
}
//////////////////////////////////////////////////////////////////
// STOP
if (flag_stop) {
// alsaPlaySound(PCM_SOUND_ID_CLICK);
if (cur_mpd_volume == 0) {
if (DEBUG)
fprintf(stderr, "DEBUG: [mgr-thread] player stopped\n");
if (!mpd_run_pause(conn, true)) {
fprintf(stderr, "ERROR: [mgr-thread] mpd: stop command failed\n");
mgr_handle_mpd_error();
continue;
}
cur_mpd_player_status = MPD_STATE_PAUSE; // for volume control
flag_stop = 0;
}
}
//////////////////////////////////////////////////////////////////
// RANDOM SWTICH MODE (SKIP2)
if (flag_skip2) {
alsaPlaySound(PCM_SOUND_ID_CLICK);
if (!mpd_run_random(conn, (cur_mpd_random > 0 ? false : true) )) {
fprintf(stderr, "ERROR: [mgr-thread] mpd: random command failed\n");
mgr_handle_mpd_error();
continue;
}
cur_mpd_random = cur_mpd_random > 0 ? 0 : 1;
}
//////////////////////////////////////////////////////////////////
// SKIP1 (skip file)
if (flag_skip1 || flag_skip2) {
if (flag_skip1) {
alsaPlaySound(PCM_SOUND_ID_CLICK);
}
if (!mpd_run_next(conn)) {
fprintf(stderr, "ERROR: [mgr-thread] mpd: skip command failed\n");
mgr_handle_mpd_error();
continue;
}
}
flag_skip1 = flag_skip2 = 0;
delay(400); //delay 40 ms
}//end while
if (DEBUG)
fprintf (stderr, "DEBUG: [mgr-thread] thread finished\n");
return thread_arg;
}
int callback_mpd(struct mg_connection *c)
{
enum mpd_cmd_ids cmd_id = get_cmd_id(c->content);
size_t n = 0;
unsigned int uint_buf, uint_buf_2;
int int_buf;
char *p_charbuf = NULL;
if(cmd_id == -1)
return MG_CLIENT_CONTINUE;
if(mpd.conn_state != MPD_CONNECTED && cmd_id != MPD_API_SET_MPDHOST &&
cmd_id != MPD_API_GET_MPDHOST && cmd_id != MPD_API_SET_MPDPASS)
return MG_CLIENT_CONTINUE;
mpd_connection_set_timeout(mpd.conn, 10000);
switch(cmd_id)
{
case MPD_API_UPDATE_DB:
mpd_run_update(mpd.conn, NULL);
break;
case MPD_API_SET_PAUSE:
mpd_run_toggle_pause(mpd.conn);
break;
case MPD_API_SET_PREV:
mpd_run_previous(mpd.conn);
break;
case MPD_API_SET_NEXT:
mpd_run_next(mpd.conn);
break;
case MPD_API_SET_PLAY:
mpd_run_play(mpd.conn);
break;
case MPD_API_SET_STOP:
mpd_run_stop(mpd.conn);
break;
case MPD_API_RM_ALL:
mpd_run_clear(mpd.conn);
break;
case MPD_API_RM_TRACK:
if(sscanf(c->content, "MPD_API_RM_TRACK,%u", &uint_buf))
mpd_run_delete_id(mpd.conn, uint_buf);
break;
case MPD_API_PLAY_TRACK:
if(sscanf(c->content, "MPD_API_PLAY_TRACK,%u", &uint_buf))
mpd_run_play_id(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_RANDOM:
if(sscanf(c->content, "MPD_API_TOGGLE_RANDOM,%u", &uint_buf))
mpd_run_random(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_REPEAT:
if(sscanf(c->content, "MPD_API_TOGGLE_REPEAT,%u", &uint_buf))
mpd_run_repeat(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_CONSUME:
if(sscanf(c->content, "MPD_API_TOGGLE_CONSUME,%u", &uint_buf))
mpd_run_consume(mpd.conn, uint_buf);
break;
case MPD_API_TOGGLE_SINGLE:
if(sscanf(c->content, "MPD_API_TOGGLE_SINGLE,%u", &uint_buf))
mpd_run_single(mpd.conn, uint_buf);
break;
case MPD_API_SET_VOLUME:
if(sscanf(c->content, "MPD_API_SET_VOLUME,%ud", &uint_buf) && uint_buf <= 100)
mpd_run_set_volume(mpd.conn, uint_buf);
break;
case MPD_API_SET_SEEK:
if(sscanf(c->content, "MPD_API_SET_SEEK,%u,%u", &uint_buf, &uint_buf_2))
mpd_run_seek_id(mpd.conn, uint_buf, uint_buf_2);
break;
case MPD_API_GET_QUEUE:
if(sscanf(c->content, "MPD_API_GET_QUEUE,%u", &uint_buf))
n = mpd_put_queue(mpd.buf, uint_buf);
break;
case MPD_API_GET_BROWSE:
if(sscanf(c->content, "MPD_API_GET_BROWSE,%u,%m[^\t\n]", &uint_buf, &p_charbuf) && p_charbuf != NULL)
{
n = mpd_put_browse(mpd.buf, p_charbuf, uint_buf);
free(p_charbuf);
}
break;
case MPD_API_ADD_TRACK:
if(sscanf(c->content, "MPD_API_ADD_TRACK,%m[^\t\n]", &p_charbuf) && p_charbuf != NULL)
{
mpd_run_add(mpd.conn, p_charbuf);
free(p_charbuf);
}
break;
case MPD_API_ADD_PLAY_TRACK:
if(sscanf(c->content, "MPD_API_ADD_PLAY_TRACK,%m[^\t\n]", &p_charbuf) && p_charbuf != NULL)
{
int_buf = mpd_run_add_id(mpd.conn, p_charbuf);
if(int_buf != -1)
mpd_run_play_id(mpd.conn, int_buf);
free(p_charbuf);
}
break;
case MPD_API_ADD_PLAYLIST:
if(sscanf(c->content, "MPD_API_ADD_PLAYLIST,%m[^\t\n]", &p_charbuf) && p_charbuf != NULL)
{
mpd_run_load(mpd.conn, p_charbuf);
free(p_charbuf);
}
break;
case MPD_API_SEARCH:
if(sscanf(c->content, "MPD_API_SEARCH,%m[^\t\n]", &p_charbuf) && p_charbuf != NULL)
{
n = mpd_search(mpd.buf, p_charbuf);
free(p_charbuf);
}
break;
#ifdef WITH_MPD_HOST_CHANGE
/* Commands allowed when disconnected from MPD server */
case MPD_API_SET_MPDHOST:
int_buf = 0;
if(sscanf(c->content, "MPD_API_SET_MPDHOST,%d,%m[^\t\n ]", &int_buf, &p_charbuf) &&
p_charbuf != NULL && int_buf > 0)
{
strncpy(mpd.host, p_charbuf, sizeof(mpd.host));
free(p_charbuf);
mpd.port = int_buf;
mpd.conn_state = MPD_RECONNECT;
return MG_CLIENT_CONTINUE;
}
break;
case MPD_API_GET_MPDHOST:
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"mpdhost\", \"data\": "
"{\"host\" : \"%s\", \"port\": \"%d\", \"passwort_set\": %s}"
"}", mpd.host, mpd.port, mpd.password ? "true" : "false");
break;
case MPD_API_SET_MPDPASS:
if(sscanf(c->content, "MPD_API_SET_MPDPASS,%m[^\t\n ]", &p_charbuf))
{
if(mpd.password)
free(mpd.password);
mpd.password = p_charbuf;
mpd.conn_state = MPD_RECONNECT;
return MG_CLIENT_CONTINUE;
}
break;
#endif
}
if(mpd.conn_state == MPD_CONNECTED && mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS)
{
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"error\", \"data\": \"%s\"}",
mpd_connection_get_error_message(mpd.conn));
/* Try to recover error */
if (!mpd_connection_clear_error(mpd.conn))
mpd.conn_state = MPD_FAILURE;
}
if(n > 0)
mg_websocket_write(c, 1, mpd.buf, n);
return MG_CLIENT_CONTINUE;
}
int main(int argc, char const *argv[])
{
if (argc < 5) {
printf("Usage: evmpd HOSTNAME PORT DEVICE HALT_COMMAND\n");
return EXIT_FAILURE;
}
struct mpd_connection *client = connect(argv[1], strtol(argv[2], NULL, 10));
struct libevdev *dev = NULL;
int fd;
int rc = 1;
fd = open(argv[3], O_RDONLY | O_NONBLOCK);
rc = libevdev_new_from_fd(fd, &dev);
if (rc < 0) {
fprintf(stderr, "Failed to init libevdev (%d)\n", strerror(-rc));
return EXIT_FAILURE;
}
printf("Input device name: \"%s\"\n", libevdev_get_name(dev));
printf("Input device ID: bus %#x vendor %#x product %#x\n",
libevdev_get_id_bustype(dev),
libevdev_get_id_vendor(dev), libevdev_get_id_product(dev));
do {
struct input_event ev;
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
if (rc == 0 && ev.value == 0) {
if (libevdev_event_is_code(&ev, EV_KEY, KEY_F4)) {
system(argv[4]);
printf("shutdown\n");
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_PLAYPAUSE)) {
struct mpd_status *status = mpd_run_status(client);
enum mpd_state state = mpd_status_get_state(status);
if (state != MPD_STATE_PLAY && state != MPD_STATE_PAUSE) {
mpd_run_play(client);
printf("play\n");
} else {
mpd_run_toggle_pause(client);
printf("toggle-pause\n");
}
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_STOPCD)) {
mpd_run_stop(client);
printf("stop\n");
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_PREVIOUSSONG)) {
mpd_run_previous(client);
printf("previous\n");
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_NEXTSONG)) {
mpd_run_next(client);
printf("next\n");
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_VOLUMEUP)) {
struct mpd_status *status = mpd_run_status(client);
int volume = mpd_status_get_volume(status);
volume += 5;
if (volume > 100) {
volume = 100;
}
mpd_run_set_volume(client, volume);
printf("set-volume %d\n", volume);
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_VOLUMEDOWN)) {
struct mpd_status *status = mpd_run_status(client);
int volume = mpd_status_get_volume(status);
volume -= 5;
if (volume < 0) {
volume = 0;
}
mpd_run_set_volume(client, volume);
printf("set-volume %d\n", volume);
} else {
printf("Event: %s %s %d\n",
libevdev_event_type_get_name(ev.type),
libevdev_event_code_get_name(ev.type, ev.code),
ev.value);
}
}
}
while (rc == LIBEVDEV_READ_STATUS_SUCCESS ||
rc == LIBEVDEV_READ_STATUS_SYNC ||
rc == -EAGAIN);
printf("rc: %d\n", rc);
if (client != NULL) {
mpd_connection_free(client);
}
return EXIT_SUCCESS;
}
void TopWidget::onVolumeBarChanged()
{
mpdconfirm(mpd_run_set_volume(mpd, volumeBar->getValue()));
}