1
0
mirror of https://github.com/SuperBFG7/ympd synced 2024-10-31 20:16:17 +00:00
ympd/src/mpd_client.c

763 lines
25 KiB
C
Raw Normal View History

2014-01-17 18:41:41 +00:00
/* ympd
(c) 2013-2014 Andrew Karpow <andy@ndyk.de>
2014-01-17 18:41:41 +00:00
This project's homepage is: http://www.ympd.org
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
2014-01-17 18:41:41 +00:00
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <libgen.h>
2013-11-04 17:18:38 +00:00
#include <mpd/client.h>
#include "mpd_client.h"
2014-02-04 16:58:10 +00:00
#include "config.h"
2014-02-22 01:11:45 +00:00
#include "json_encode.h"
2013-11-04 17:18:38 +00:00
2015-04-28 09:08:21 +00:00
/* forward declaration */
static int mpd_notify_callback(struct mg_connection *c, enum mg_event ev);
2014-02-16 18:46:53 +00:00
const char * mpd_cmd_strs[] = {
MPD_CMDS(GEN_STR)
};
2013-11-04 17:18:38 +00:00
char * get_arg1 (char *p) {
return strchr(p, ',') + 1;
}
char * get_arg2 (char *p) {
return get_arg1(get_arg1(p));
}
2014-02-16 18:46:53 +00:00
static inline enum mpd_cmd_ids get_cmd_id(char *cmd)
2013-11-04 17:18:38 +00:00
{
2014-02-16 18:46:53 +00:00
for(int i = 0; i < sizeof(mpd_cmd_strs)/sizeof(mpd_cmd_strs[0]); i++)
if(!strncmp(cmd, mpd_cmd_strs[i], strlen(mpd_cmd_strs[i])))
return i;
2013-11-09 01:07:03 +00:00
2014-02-16 18:46:53 +00:00
return -1;
}
2013-11-09 01:07:03 +00:00
2014-02-16 18:46:53 +00:00
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;
2014-02-16 18:46:53 +00:00
if(cmd_id == -1)
return MG_TRUE;
2014-02-16 18:46:53 +00:00
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_TRUE;
2014-02-16 18:46:53 +00:00
switch(cmd_id)
{
case MPD_API_UPDATE_DB:
mpd_run_update(mpd.conn, NULL);
2013-11-09 01:07:03 +00:00
break;
2014-02-16 18:46:53 +00:00
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_MOVE_TRACK:
if (sscanf(c->content, "MPD_API_MOVE_TRACK,%u,%u", &uint_buf, &uint_buf_2) == 2)
{
uint_buf -= 1;
uint_buf_2 -= 1;
mpd_run_move(mpd.conn, uint_buf, uint_buf_2);
}
break;
2014-02-16 18:46:53 +00:00
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;
2015-04-28 09:08:21 +00:00
case MPD_API_GET_OUTPUTS:
2015-05-01 21:51:44 +00:00
mpd.buf_size = mpd_put_outputs(mpd.buf, 1);
2015-04-28 09:08:21 +00:00
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;
2014-02-16 18:46:53 +00:00
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;
2014-02-22 01:11:45 +00:00
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;
2014-02-16 18:46:53 +00:00
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);
2014-02-16 18:46:53 +00:00
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);
2014-02-16 18:46:53 +00:00
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;
2015-09-02 17:24:52 +00:00
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));
2015-09-02 17:24:52 +00:00
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;
2014-02-04 16:58:10 +00:00
#ifdef WITH_MPD_HOST_CHANGE
2014-02-16 18:46:53 +00:00
/* 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);
2014-02-16 18:46:53 +00:00
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;
2014-02-16 18:46:53 +00:00
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);
2015-04-24 22:39:16 +00:00
mpd.password = strdup(token);
mpd.conn_state = MPD_RECONNECT;
2015-04-24 22:39:16 +00:00
free(p_charbuf);
return MG_TRUE;
out_set_pass:
free(p_charbuf);
2014-02-16 18:46:53 +00:00
break;
2014-02-04 16:58:10 +00:00
#endif
2014-02-16 18:46:53 +00:00
}
2014-02-16 18:46:53 +00:00
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));
2013-11-09 01:07:03 +00:00
2014-02-16 18:46:53 +00:00
/* Try to recover error */
if (!mpd_connection_clear_error(mpd.conn))
mpd.conn_state = MPD_FAILURE;
2013-11-09 01:07:03 +00:00
}
2014-02-16 18:46:53 +00:00
if(n > 0)
mg_websocket_write(c, 1, mpd.buf, n);
return MG_TRUE;
2014-02-16 18:46:53 +00:00
}
int mpd_close_handler(struct mg_connection *c)
{
/* Cleanup session data */
if(c->connection_param)
free(c->connection_param);
2013-11-09 01:07:03 +00:00
return 0;
2013-11-04 17:18:38 +00:00
}
static int mpd_notify_callback(struct mg_connection *c, enum mg_event ev) {
2014-02-16 18:46:53 +00:00
size_t n;
if(!c->is_websocket)
return MG_TRUE;
2014-02-16 18:46:53 +00:00
if(c->callback_param)
{
/* error message? */
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"error\",\"data\":\"%s\"}",
(const char *)c->callback_param);
mg_websocket_write(c, 1, mpd.buf, n);
return MG_TRUE;
2014-02-16 18:46:53 +00:00
}
if(!c->connection_param)
c->connection_param = calloc(1, sizeof(struct t_mpd_client_session));
struct t_mpd_client_session *s = (struct t_mpd_client_session *)c->connection_param;
if(mpd.conn_state != MPD_CONNECTED) {
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"disconnected\"}");
mg_websocket_write(c, 1, mpd.buf, n);
}
else
{
mg_websocket_write(c, 1, mpd.buf, mpd.buf_size);
if(s->song_id != mpd.song_id)
{
n = mpd_put_current_song(mpd.buf);
mg_websocket_write(c, 1, mpd.buf, n);
s->song_id = mpd.song_id;
}
if(s->queue_version != mpd.queue_version)
{
n = snprintf(mpd.buf, MAX_SIZE, "{\"type\":\"update_queue\"}");
2014-02-16 18:46:53 +00:00
mg_websocket_write(c, 1, mpd.buf, n);
s->queue_version = mpd.queue_version;
}
}
return MG_TRUE;
2014-02-16 18:46:53 +00:00
}
void mpd_poll(struct mg_server *s)
2013-11-04 17:18:38 +00:00
{
2014-02-16 18:46:53 +00:00
switch (mpd.conn_state) {
2013-11-09 01:07:03 +00:00
case MPD_DISCONNECTED:
/* Try to connect */
2014-02-16 18:46:53 +00:00
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;
2013-11-09 01:07:03 +00:00
return;
}
2014-02-16 18:46:53 +00:00
if (mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS) {
fprintf(stderr, "MPD connection: %s\n", mpd_connection_get_error_message(mpd.conn));
for (struct mg_connection *c = mg_next(s, NULL); c != NULL; c = mg_next(s, c))
{
c->callback_param = (void *)mpd_connection_get_error_message(mpd.conn);
mpd_notify_callback(c, MG_POLL);
}
2014-02-16 18:46:53 +00:00
mpd.conn_state = MPD_FAILURE;
2013-11-09 01:07:03 +00:00
return;
}
2014-02-16 18:46:53 +00:00
if(mpd.password && !mpd_run_password(mpd.conn, mpd.password))
{
fprintf(stderr, "MPD connection: %s\n", mpd_connection_get_error_message(mpd.conn));
for (struct mg_connection *c = mg_next(s, NULL); c != NULL; c = mg_next(s, c))
{
c->callback_param = (void *)mpd_connection_get_error_message(mpd.conn);
mpd_notify_callback(c, MG_POLL);
}
2014-02-16 18:46:53 +00:00
mpd.conn_state = MPD_FAILURE;
2013-11-09 01:07:03 +00:00
return;
}
2014-02-16 18:46:53 +00:00
fprintf(stderr, "MPD connected.\n");
mpd_connection_set_timeout(mpd.conn, 10000);
2014-02-16 18:46:53 +00:00
mpd.conn_state = MPD_CONNECTED;
2015-04-28 09:08:21 +00:00
/* write outputs */
2015-05-01 21:51:44 +00:00
mpd.buf_size = mpd_put_outputs(mpd.buf, 1);
2015-04-28 09:08:21 +00:00
for (struct mg_connection *c = mg_next(s, NULL); c != NULL; c = mg_next(s, c))
{
c->callback_param = NULL;
mpd_notify_callback(c, MG_POLL);
}
2013-11-09 01:07:03 +00:00
break;
case MPD_FAILURE:
2014-02-16 18:46:53 +00:00
fprintf(stderr, "MPD connection failed.\n");
2013-11-09 01:07:03 +00:00
2014-02-16 18:46:53 +00:00
case MPD_DISCONNECT:
2014-02-04 16:58:10 +00:00
case MPD_RECONNECT:
2014-02-16 18:46:53 +00:00
if(mpd.conn != NULL)
mpd_connection_free(mpd.conn);
mpd.conn = NULL;
mpd.conn_state = MPD_DISCONNECTED;
2013-11-09 01:07:03 +00:00
break;
case MPD_CONNECTED:
2014-02-16 18:46:53 +00:00
mpd.buf_size = mpd_put_state(mpd.buf, &mpd.song_id, &mpd.queue_version);
for (struct mg_connection *c = mg_next(s, NULL); c != NULL; c = mg_next(s, c))
{
c->callback_param = NULL;
mpd_notify_callback(c, MG_POLL);
}
2015-05-01 21:51:44 +00:00
mpd.buf_size = mpd_put_outputs(mpd.buf, 0);
2015-04-28 09:08:21 +00:00
for (struct mg_connection *c = mg_next(s, NULL); c != NULL; c = mg_next(s, c))
{
c->callback_param = NULL;
mpd_notify_callback(c, MG_POLL);
}
2013-11-09 01:07:03 +00:00
break;
}
2013-11-04 17:18:38 +00:00
}
2013-11-05 23:15:24 +00:00
char* mpd_get_title(struct mpd_song const *song)
2013-11-04 23:17:28 +00:00
{
2014-02-22 01:11:45 +00:00
char *str;
2013-11-05 23:15:24 +00:00
2013-11-09 01:07:03 +00:00
str = (char *)mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
if(str == NULL){
str = basename((char *)mpd_song_get_uri(song));
}
2013-11-05 23:15:24 +00:00
return str;
2013-11-04 23:17:28 +00:00
}
char* mpd_get_album(struct mpd_song const *song)
{
char *str;
str = (char *)mpd_song_get_tag(song, MPD_TAG_ALBUM, 0);
if(str == NULL){
str = "-";
}
return str;
}
char* mpd_get_artist(struct mpd_song const *song)
{
char *str;
str = (char *)mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);
if(str == NULL){
str = "-";
}
return str;
}
2014-11-20 19:17:16 +00:00
char* mpd_get_year(struct mpd_song const *song)
{
char *str;
str = (char *)mpd_song_get_tag(song, MPD_TAG_DATE, 0);
if(str == NULL){
str = "-";
2014-11-20 19:17:16 +00:00
}
return str;
}
2014-01-17 15:26:26 +00:00
int mpd_put_state(char *buffer, int *current_song_id, unsigned *queue_version)
2013-11-04 17:18:38 +00:00
{
2013-11-09 01:07:03 +00:00
struct mpd_status *status;
int len;
2014-02-16 18:46:53 +00:00
status = mpd_run_status(mpd.conn);
2013-11-09 01:07:03 +00:00
if (!status) {
2014-02-16 18:46:53 +00:00
fprintf(stderr, "MPD mpd_run_status: %s\n", mpd_connection_get_error_message(mpd.conn));
mpd.conn_state = MPD_FAILURE;
2013-11-09 01:07:03 +00:00
return 0;
}
len = snprintf(buffer, MAX_SIZE,
"{\"type\":\"state\", \"data\":{"
" \"state\":%d, \"volume\":%d, \"repeat\":%d,"
" \"single\":%d, \"crossfade\":%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_crossfade(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));
2013-11-09 01:07:03 +00:00
2014-01-17 15:26:26 +00:00
*current_song_id = mpd_status_get_song_id(status);
*queue_version = mpd_status_get_queue_version(status);
2013-11-09 01:07:03 +00:00
mpd_status_free(status);
return len;
2013-11-04 17:18:38 +00:00
}
2015-05-01 21:51:44 +00:00
int mpd_put_outputs(char *buffer, int names)
2015-04-28 09:08:21 +00:00
{
struct mpd_output *out;
int nout;
char *str, *strend;
str = buffer;
strend = buffer+MAX_SIZE;
2015-05-01 21:51:44 +00:00
str += snprintf(str, strend-str, "{\"type\":\"%s\", \"data\":{",
2015-05-25 16:11:22 +00:00
names ? "outputnames" : "outputs");
2015-04-28 09:08:21 +00:00
mpd_send_outputs(mpd.conn);
nout = 0;
while ((out = mpd_recv_output(mpd.conn)) != NULL) {
if (nout++)
*str++ = ',';
2015-05-01 21:51:44 +00:00
if (names)
str += snprintf(str, strend - str, " \"%d\":\"%s\"",
mpd_output_get_id(out), mpd_output_get_name(out));
else
str += snprintf(str, strend-str, " \"%d\":%d",
mpd_output_get_id(out), mpd_output_get_enabled(out));
2015-04-28 09:08:21 +00:00
mpd_output_free(out);
}
2015-05-01 22:07:37 +00:00
if (!mpd_response_finish(mpd.conn)) {
fprintf(stderr, "MPD outputs: %s\n", mpd_connection_get_error_message(mpd.conn));
2015-05-01 22:07:37 +00:00
mpd_connection_clear_error(mpd.conn);
return 0;
2015-05-01 22:07:37 +00:00
}
2015-04-28 09:08:21 +00:00
str += snprintf(str, strend-str, " }}");
return str-buffer;
}
2013-11-07 09:09:40 +00:00
int mpd_put_current_song(char *buffer)
2013-11-04 17:18:38 +00:00
{
char *cur = buffer;
const char *end = buffer + MAX_SIZE;
2013-11-09 01:07:03 +00:00
struct mpd_song *song;
2013-11-04 17:18:38 +00:00
2014-02-16 18:46:53 +00:00
song = mpd_run_current_song(mpd.conn);
2013-11-09 01:07:03 +00:00
if(song == NULL)
return 0;
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"type\": \"song_change\", \"data\":{\"pos\":");
cur += json_emit_int(cur, end - cur, mpd_song_get_pos(song));
cur += json_emit_raw_str(cur, end - cur, ",\"title\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_title(song));
if(mpd_song_get_tag(song, MPD_TAG_ARTIST, 0) != NULL)
2014-02-22 01:11:45 +00:00
{
cur += json_emit_raw_str(cur, end - cur, ",\"artist\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_song_get_tag(song, MPD_TAG_ARTIST, 0));
}
if(mpd_song_get_tag(song, MPD_TAG_ALBUM, 0) != NULL)
2014-02-22 01:11:45 +00:00
{
cur += json_emit_raw_str(cur, end - cur, ",\"album\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_song_get_tag(song, MPD_TAG_ALBUM, 0));
}
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "}}");
2013-11-09 01:07:03 +00:00
mpd_song_free(song);
2014-02-16 18:46:53 +00:00
mpd_response_finish(mpd.conn);
2013-11-09 01:07:03 +00:00
return cur - buffer;
2013-11-04 17:18:38 +00:00
}
2014-02-22 01:11:45 +00:00
int mpd_put_queue(char *buffer, unsigned int offset)
2013-11-04 17:18:38 +00:00
{
2013-11-09 01:07:03 +00:00
char *cur = buffer;
const char *end = buffer + MAX_SIZE;
struct mpd_entity *entity;
2013-11-04 17:18:38 +00:00
2014-02-22 01:11:45 +00:00
if (!mpd_send_list_queue_range_meta(mpd.conn, offset, offset+MAX_ELEMENTS_PER_PAGE))
RETURN_ERROR_AND_RECOVER("mpd_send_list_queue_meta");
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"queue\",\"data\":[ ");
2013-11-04 17:18:38 +00:00
2014-02-16 18:46:53 +00:00
while((entity = mpd_recv_entity(mpd.conn)) != NULL) {
2013-11-07 09:09:40 +00:00
const struct mpd_song *song;
2013-11-04 17:18:38 +00:00
2013-11-09 01:07:03 +00:00
if(mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG) {
song = mpd_entity_get_song(entity);
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"id\":");
cur += json_emit_int(cur, end - cur, mpd_song_get_id(song));
cur += json_emit_raw_str(cur, end - cur, ",\"pos\":");
cur += json_emit_int(cur, end - cur, mpd_song_get_pos(song));
cur += json_emit_raw_str(cur, end - cur, ",\"duration\":");
cur += json_emit_int(cur, end - cur, mpd_song_get_duration(song));
cur += json_emit_raw_str(cur, end - cur, ",\"artist\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_artist(song));
cur += json_emit_raw_str(cur, end - cur, ",\"album\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_album(song));
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, ",\"title\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_title(song));
cur += json_emit_raw_str(cur, end - cur, "},");
2013-11-09 01:07:03 +00:00
}
mpd_entity_free(entity);
}
/* remove last ',' */
cur--;
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "]}");
2013-11-09 01:07:03 +00:00
return cur - buffer;
2013-11-07 09:09:40 +00:00
}
2013-11-04 17:18:38 +00:00
2014-02-22 01:11:45 +00:00
int mpd_put_browse(char *buffer, char *path, unsigned int offset)
2013-11-07 09:09:40 +00:00
{
2013-11-09 01:07:03 +00:00
char *cur = buffer;
const char *end = buffer + MAX_SIZE;
struct mpd_entity *entity;
2014-02-22 01:11:45 +00:00
unsigned int entity_count = 0;
2013-11-09 01:07:03 +00:00
if (!mpd_send_list_meta(mpd.conn, path))
RETURN_ERROR_AND_RECOVER("mpd_send_list_meta");
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"browse\",\"data\":[ ");
2013-11-07 09:09:40 +00:00
2014-02-16 18:46:53 +00:00
while((entity = mpd_recv_entity(mpd.conn)) != NULL) {
2013-11-07 09:09:40 +00:00
const struct mpd_song *song;
const struct mpd_directory *dir;
const struct mpd_playlist *pl;
2014-02-22 01:11:45 +00:00
if(offset > entity_count)
{
mpd_entity_free(entity);
entity_count++;
continue;
}
else if(offset + MAX_ELEMENTS_PER_PAGE - 1 < entity_count)
{
mpd_entity_free(entity);
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"wrap\",\"count\":");
cur += json_emit_int(cur, end - cur, entity_count);
cur += json_emit_raw_str(cur, end - cur, "} ");
break;
}
2013-11-07 09:09:40 +00:00
switch (mpd_entity_get_type(entity)) {
2013-11-09 01:07:03 +00:00
case MPD_ENTITY_TYPE_UNKNOWN:
break;
case MPD_ENTITY_TYPE_SONG:
song = mpd_entity_get_song(entity);
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"song\",\"uri\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_song_get_uri(song));
cur += json_emit_raw_str(cur, end - cur, ",\"album\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_album(song));
2014-11-20 19:17:16 +00:00
cur += json_emit_raw_str(cur, end - cur, ",\"artist\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_artist(song));
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, ",\"duration\":");
cur += json_emit_int(cur, end - cur, mpd_song_get_duration(song));
cur += json_emit_raw_str(cur, end - cur, ",\"title\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_title(song));
cur += json_emit_raw_str(cur, end - cur, "},");
2013-11-09 01:07:03 +00:00
break;
case MPD_ENTITY_TYPE_DIRECTORY:
dir = mpd_entity_get_directory(entity);
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"directory\",\"dir\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_directory_get_path(dir));
cur += json_emit_raw_str(cur, end - cur, "},");
2013-11-09 01:07:03 +00:00
break;
case MPD_ENTITY_TYPE_PLAYLIST:
pl = mpd_entity_get_playlist(entity);
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"playlist\",\"plist\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_playlist_get_path(pl));
cur += json_emit_raw_str(cur, end - cur, "},");
2013-11-09 01:07:03 +00:00
break;
2013-11-07 09:09:40 +00:00
}
2013-11-09 01:07:03 +00:00
mpd_entity_free(entity);
2014-02-22 01:11:45 +00:00
entity_count++;
2013-11-09 01:07:03 +00:00
}
2013-11-04 17:18:38 +00:00
2014-02-16 18:46:53 +00:00
if (mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(mpd.conn)) {
fprintf(stderr, "MPD mpd_send_list_meta: %s\n", mpd_connection_get_error_message(mpd.conn));
mpd.conn_state = MPD_FAILURE;
2013-11-07 09:09:40 +00:00
return 0;
}
2013-11-09 01:07:03 +00:00
/* remove last ',' */
cur--;
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "]}");
2013-11-09 01:07:03 +00:00
return cur - buffer;
}
2014-02-16 18:46:53 +00:00
int mpd_search(char *buffer, char *searchstr)
{
2014-02-22 01:11:45 +00:00
int i = 0;
char *cur = buffer;
const char *end = buffer + MAX_SIZE;
struct mpd_song *song;
if(mpd_search_db_songs(mpd.conn, false) == false)
RETURN_ERROR_AND_RECOVER("mpd_search_db_songs");
else if(mpd_search_add_any_tag_constraint(mpd.conn, MPD_OPERATOR_DEFAULT, searchstr) == false)
RETURN_ERROR_AND_RECOVER("mpd_search_add_any_tag_constraint");
else if(mpd_search_commit(mpd.conn) == false)
RETURN_ERROR_AND_RECOVER("mpd_search_commit");
else {
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"search\",\"data\":[ ");
while((song = mpd_recv_song(mpd.conn)) != NULL) {
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"song\",\"uri\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_song_get_uri(song));
2014-11-20 19:17:16 +00:00
cur += json_emit_raw_str(cur, end - cur, ",\"album\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_album(song));
cur += json_emit_raw_str(cur, end - cur, ",\"artist\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_artist(song));
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, ",\"duration\":");
cur += json_emit_int(cur, end - cur, mpd_song_get_duration(song));
cur += json_emit_raw_str(cur, end - cur, ",\"title\":");
cur += json_emit_quoted_str(cur, end - cur, mpd_get_title(song));
cur += json_emit_raw_str(cur, end - cur, "},");
mpd_song_free(song);
2014-02-22 01:11:45 +00:00
/* Maximum results */
if(i++ >= 300)
{
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"wrap\"},");
break;
}
}
/* remove last ',' */
cur--;
2014-02-22 01:11:45 +00:00
cur += json_emit_raw_str(cur, end - cur, "]}");
}
2013-11-09 01:07:03 +00:00
return cur - buffer;
}
2014-02-16 18:46:53 +00:00
void mpd_disconnect()
{
mpd.conn_state = MPD_DISCONNECT;
mpd_poll(NULL);
2014-03-18 00:30:01 +00:00
}