std::string Mpd::getTag(const char *_album, mpd_tag_type type) {
std::string tagRet = "";
mpd_song *song;
if (!mpd_search_db_songs(conn, false)) { err(); return NULL; }
if (!mpd_search_add_tag_constraint(conn, MPD_OPERATOR_DEFAULT, MPD_TAG_ALBUM, _album)) { err(); return NULL; }
if (!mpd_search_commit(conn)) { err(); return NULL; }
if (type == MPD_TAG_UNKNOWN) {
if ((song = mpd_recv_song(conn)) != NULL) {
if (mpd_song_get_uri(song) != NULL)
tagRet = mpd_song_get_uri(song);
else
tagRet = "";
}
} else if ((song = mpd_recv_song(conn)) != NULL) {
if (mpd_song_get_tag(song, type, 0) != NULL)
tagRet = mpd_song_get_tag(song, type, 0);
else
tagRet = "";
}
mpd_song_free(song);
if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { err(); return NULL; }
if (!mpd_response_finish(conn)) { err(); return NULL; }
return tagRet;
}
int cmd_tab ( int argc, char ** argv, struct mpd_connection *conn )
{
struct mpd_song *song;
char empty[] = "";
char *dir = empty;
char *tmp = NULL;
if (argc == 1) {
if (strrchr(argv[0], '/')) {
dir = strdup(argv[0]);
if (!dir) return 0;
tmp = strrchr(dir, '/');
if (tmp) *tmp = '\0'; // XXX: It's unpossible for tmp to be NULL.
}
}
if (!mpd_send_list_all(conn, dir))
printErrorAndExit(conn);
if (*dir) free(dir);
while ((song = mpd_recv_song(conn)) != NULL) {
if (argc != 1 ||
strncmp(mpd_song_get_uri(song), argv[0],
strlen(argv[0])) == 0)
printf("%s\n",
charset_from_utf8(mpd_song_get_uri(song)));
mpd_song_free(song);
}
my_finishCommand(conn);
return 0;
}
/**
* Checks if a mpd_song might be an FM4 stream
*
* @return true if it looks like an FM4 stream, false otherwise
*/
bool
fm4_is_fm4_stream(struct mpd_song *song)
{
int rank = 0;
const char *title = NULL;
const char *uri = NULL;
const char *title_prefix_fm4 = "FM4";
if (song == NULL)
return false;
/* Information is contained in the title tag */
title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
uri = mpd_song_get_uri(song);
if (title == NULL)
return false;
if (strcmp("http://mp3stream1.apasf.apa.at:8000/", uri) == 0)
rank += 10;
if (strncmp(title_prefix_fm4, title, sizeof(title_prefix_fm4)))
rank += 5;
if (rank >= FM4_THRESHOLD)
return true;
return false;
}
static void
song_changed(const struct mpd_song *song)
{
g_assert(song != NULL);
if (mpd_song_get_tag(song, MPD_TAG_ARTIST, 0) == NULL ||
mpd_song_get_tag(song, MPD_TAG_TITLE, 0) == NULL) {
g_message("New song detected with tags missing (%s)",
mpd_song_get_uri(song));
g_timer_start(timer);
return;
}
g_timer_start(timer);
g_debug("New song detected (%s - %s), id: %u, pos: %u",
mpd_song_get_tag(song, MPD_TAG_ARTIST, 0),
mpd_song_get_tag(song, MPD_TAG_TITLE, 0),
mpd_song_get_id(song), mpd_song_get_pos(song));
as_now_playing(mpd_song_get_tag(song, MPD_TAG_ARTIST, 0),
mpd_song_get_tag(song, MPD_TAG_TITLE, 0),
mpd_song_get_tag(song, MPD_TAG_ALBUM, 0),
mpd_song_get_tag(song, MPD_TAG_MUSICBRAINZ_TRACKID, 0),
mpd_song_get_duration(song));
}
static int
rmtag_song(struct mpdcron_connection *conn, const char *tag, const char *expr)
{
int changes;
if (expr != NULL) {
if (!mpdcron_rmtag_expr(conn, expr, tag, &changes)) {
eulog(LOG_ERR, "Failed to remove tag from song: %s",
conn->error->message);
return 1;
}
}
else {
char *esc_uri, *myexpr;
struct mpd_song *song;
if ((song = load_current_song()) == NULL)
return 1;
esc_uri = quote(mpd_song_get_uri(song));
myexpr = g_strdup_printf("uri=%s", esc_uri);
g_free(esc_uri);
mpd_song_free(song);
if (!mpdcron_rmtag_expr(conn, myexpr, tag, &changes)) {
eulog(LOG_ERR, "Failed to remove tag from current playing song: %s",
conn->error->message);
g_free(myexpr);
return 1;
}
g_free(myexpr);
}
printf("Modified %d entries\n", changes);
return 0;
}
std::string Song::getURI(unsigned idx) const
{
assert(m_song);
if (idx > 0)
return "";
else
return mpd_song_get_uri(m_song.get());
}
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* 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 = basename((char *)mpd_song_get_uri(song));
}
return str;
}
char* mpd_get_title(struct mpd_song const *song)
{
char *str;
str = (char *)mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
if(str == NULL){
str = basename((char *)mpd_song_get_uri(song));
}
return str;
}
std::string Song::getDirectory(unsigned idx) const
{
assert(m_song);
if (idx > 0 || isStream())
return "";
const char *uri = mpd_song_get_uri(m_song.get());
const char *name = strrchr(uri, '/');
if (name)
return std::string(uri, name-uri);
else
return "/";
}
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;
}
int main() {
char fullpath[100], text[100];
char *buf = NULL, *sub = NULL, *state = NULL;
conn = mpd_connection_new(NULL, 0, 10000);
notify = notify_notification_new(NULL, NULL, NULL);
notify_init("mpdnotify");
while(mpd_run_idle_mask(conn, MPD_IDLE_PLAYER)) {
mpd_command_list_begin(conn, true);
mpd_send_status(conn);
mpd_send_current_song(conn);
mpd_command_list_end(conn);
status = mpd_recv_status(conn);
if(mpd_status_get_state(status) == MPD_STATE_PLAY)
state = "Playing:";
else if(mpd_status_get_state(status) == MPD_STATE_PAUSE)
state = "Paused:";
else
state = "Stopped:";
mpd_response_next(conn);
song = mpd_recv_song(conn);
if(song) {
artist = mpd_song_get_tag(song, MPD_TAG_ARTIST, 0);
title = mpd_song_get_tag(song, MPD_TAG_TITLE, 0);
path = mpd_song_get_uri(song);
sprintf(text, "%s - %s", artist, title);
buf = fullpath;
sub = strrchr(path, '/');
buf = strcpy(buf, mpdroot);
buf = strncat(buf, path, strlen(path) - strlen(sub) + 1);
buf = strcat(buf, albumart);
icon = gdk_pixbuf_new_from_file(fullpath, NULL);
if(icon)
notify_notification_update(notify, state, text, NULL);
else
notify_notification_update(notify, state, text, "sound");
notify_notification_set_icon_from_pixbuf(notify, icon);
notify_notification_show(notify, &gerror);
mpd_song_free(song);
}
mpd_response_finish(conn);
}
mpd_connection_free(conn);
notify_uninit();
return 0;
}
char* 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 = basename((char *)mpd_song_get_uri(song));
if (str == NULL)
str = nullstr;
}
return str;
}
static void getFilename(RESULT * result)
{
const char *value = NULL;
mpd_update();
if (currentSong != NULL) {
value = mpd_song_get_uri(currentSong);
}
if (value)
SetResult(&result, R_STRING, charset_from_utf8(value));
else
SetResult(&result, R_STRING, "");
}
static void
song_ended(const struct mpd_song *song)
{
int elapsed;
g_assert(song != NULL);
elapsed = g_timer_elapsed(timer, NULL);
if (mpd_song_get_tag(song, MPD_TAG_ARTIST, 0) == NULL ||
mpd_song_get_tag(song, MPD_TAG_TITLE, 0) == NULL) {
g_message("Song (%s) has missing tags, skipping",
mpd_song_get_uri(song));
return;
}
else if (!played_long_enough(elapsed, mpd_song_get_duration(song))) {
g_message("Song (%s - %s), id: %u, pos: %u not played long enough, skipping",
mpd_song_get_tag(song, MPD_TAG_ARTIST, 0),
mpd_song_get_tag(song, MPD_TAG_TITLE, 0),
mpd_song_get_id(song), mpd_song_get_pos(song));
return;
}
g_debug("Submitting old song (%s - %s), id: %u, pos: %u",
mpd_song_get_tag(song, MPD_TAG_ARTIST, 0),
mpd_song_get_tag(song, MPD_TAG_TITLE, 0),
mpd_song_get_id(song), mpd_song_get_pos(song));
/* FIXME: libmpdclient doesn't have any way to fetch the musicbrainz id.
*/
as_songchange(mpd_song_get_uri(song),
mpd_song_get_tag(song, MPD_TAG_ARTIST, 0),
mpd_song_get_tag(song, MPD_TAG_TITLE, 0),
mpd_song_get_tag(song, MPD_TAG_ALBUM, 0),
mpd_song_get_tag(song, MPD_TAG_MUSICBRAINZ_TRACKID, 0),
mpd_song_get_duration(song) > 0
? mpd_song_get_duration(song)
: g_timer_elapsed(timer, NULL),
NULL);
}
void get_random_song(struct mpd_connection *conn, char *str, char *path)
{
struct mpd_entity *entity;
int listened0 = 65000,
skipnum, numberofsongs = 0;
struct mpd_stats *stats = mpd_run_stats(conn);
if (stats == NULL)
return;
numberofsongs = mpd_stats_get_number_of_songs(stats);
mpd_stats_free(stats);
skipnum = rand() % numberofsongs;
syslog(LOG_DEBUG, "%s: path %s; number of songs: %i skip: %i\n",
__func__, path, numberofsongs, skipnum);
if (!mpd_send_list_all_meta(conn, ""))//path))
{
syslog(LOG_ERR, "%s: error: mpd_send_list_meta %s\n", __func__, path);
return;
}
while((entity = mpd_recv_entity(conn)) != NULL)
{
const struct mpd_song *song;
if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG)
{
if (skipnum-- > 0)
continue;
int listened;
song = mpd_entity_get_song(entity);
listened = db_get_song_numplayed(mpd_get_title(song),
mpd_get_artist(song));
if (listened < listened0) {
listened0 = listened;
syslog(LOG_DEBUG, "listened: %i ", listened);
int probability = 50 +
db_get_song_rating(mpd_get_title(song),
mpd_get_artist(song));
syslog(LOG_DEBUG, "probability: %i ", probability);
bool Yes = (rand() % 100) < probability;
if (Yes) {
sprintf(str, "%s", mpd_song_get_uri(song));
syslog(LOG_DEBUG, "uri: %s ", str);
syslog(LOG_DEBUG, "title: %s ", mpd_get_title(song));
syslog(LOG_DEBUG, "artist: %s", mpd_get_artist(song));
}
}
}
mpd_entity_free(entity);
}
}
static int fetch_items(MENU_SEARCH *menu,char *str,CLIENT_OBJECT *cli,DB_OBJECT *db)
{
if (!(str && strlen(str)))
return 1;
/* send query */
if (!mpd_search_db_songs(cli->conn,false))
clear_or_exit_on_error(cli->conn);
if (!mpd_search_add_tag_constraint(cli->conn,MPD_OPERATOR_DEFAULT,MPD_TAG_TITLE,str))
clear_or_exit_on_error(cli->conn);
if (!mpd_search_commit(cli->conn))
clear_or_exit_on_error(cli->conn);
/* process response */
int block = 1024;
menu->items = (MENU_SEARCH_ITEM*)calloc(block,sizeof(MENU_SEARCH_ITEM));
struct mpd_song *song;
int i = 0;
while ((song = mpd_recv_song(cli->conn))) {
/* realloc if memory not enough */
if (i >= block) {
block *= 2;
menu->items = (MENU_SEARCH_ITEM*)realloc(menu->items,block*sizeof(MENU_SEARCH_ITEM));
}
unsigned id = mpd_song_get_id(song);
const char *uri = mpd_song_get_uri(song);
const char *title = mpd_song_get_tag(song,MPD_TAG_TITLE,0);
menu->items[i].id = id;
menu->items[i].title = (char *)malloc((strlen(title)+1)*sizeof(char));
strcpy(menu->items[i].title,title);
menu->items[i++].node = get_node_by_uri(db,uri);
mpd_song_free(song);
}
if (mpd_connection_get_error(cli->conn) == MPD_ERROR_SUCCESS)
mpd_response_finish(cli->conn);
else
clear_or_exit_on_error(cli->conn);
menu->num = i;
return 0;
}
/* create a list suitable for GCompletion from path */
GList *
gcmp_list_from_path(struct mpdclient *c, const gchar *path,
GList *list, gint types)
{
struct mpd_connection *connection;
struct mpd_entity *entity;
connection = mpdclient_get_connection(c);
if (connection == NULL)
return list;
mpd_send_list_meta(connection, path);
while ((entity = mpd_recv_entity(connection)) != NULL) {
char *name;
if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_DIRECTORY &&
types & GCMP_TYPE_DIR) {
const struct mpd_directory *dir =
mpd_entity_get_directory(entity);
gchar *tmp = utf8_to_locale(mpd_directory_get_path(dir));
gsize size = strlen(tmp)+2;
name = g_malloc(size);
g_strlcpy(name, tmp, size);
g_strlcat(name, "/", size);
g_free(tmp);
} else if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG &&
types & GCMP_TYPE_FILE) {
const struct mpd_song *song =
mpd_entity_get_song(entity);
name = utf8_to_locale(mpd_song_get_uri(song));
} else if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_PLAYLIST &&
types & GCMP_TYPE_PLAYLIST) {
const struct mpd_playlist *playlist =
mpd_entity_get_playlist(entity);
name = utf8_to_locale(mpd_playlist_get_path(playlist));
} else {
mpd_entity_free(entity);
continue;
}
list = g_list_append(list, name);
mpd_entity_free(entity);
}
return list;
}
std::string Song::getName(unsigned idx) const
{
assert(m_song);
mpd_song *s = m_song.get();
const char *res = mpd_song_get_tag(s, MPD_TAG_NAME, idx);
if (res)
return res;
else if (idx > 0)
return "";
const char *uri = mpd_song_get_uri(s);
const char *name = strrchr(uri, '/');
if (name)
return name+1;
else
return uri;
}
int mpd_search(char *buffer, char *searchstr)
{
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 {
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"search\",\"data\":[ ");
while((song = mpd_recv_song(mpd.conn)) != NULL) {
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));
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, ",\"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);
/* Maximum results */
if(i++ >= 300)
{
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"wrap\"},");
break;
}
}
/* remove last ',' */
cur--;
cur += json_emit_raw_str(cur, end - cur, "]}");
}
return cur - buffer;
}
/* if no tag is availabe, use filename */
static void getArtist(RESULT * result)
{
const char *value = NULL;
mpd_update();
if (currentSong != NULL) {
value = mpd_song_get_tag(currentSong, MPD_TAG_ARTIST, 0);
if (!value) {
value = mpd_song_get_tag(currentSong, MPD_TAG_ALBUM_ARTIST, 0);
}
if (!value) {
value = mpd_song_get_uri(currentSong);
}
}
if (value)
SetResult(&result, R_STRING, charset_from_utf8(value));
else
SetResult(&result, R_STRING, "");
}
int mpd_delete_current_song(struct mpd_connection *conn)
{
struct mpd_song *song;
char *currentsonguri = NULL;
song = mpd_run_current_song(conn);
if(song == NULL)
return 0;
db_update_song_rating(mpd_get_title(song),
mpd_song_get_tag(song, MPD_TAG_ARTIST, 0), -5);
currentsonguri = mpd_song_get_uri(song);
printf("%s: let's delete song: %s\n", __func__, currentsonguri);
delete_file_forever(currentsonguri);
mpd_song_free(song);
return 1;
}
void get_song_to_delete(char *str)
{
struct mpd_entity *entity;
int rating0 = 65000;
if (!mpd_send_list_meta(mpd.conn, "/")) {
syslog(LOG_DEBUG, "error: mpd_send_list_meta\n");
return;
}
while((entity = mpd_recv_entity(mpd.conn)) != NULL) {
if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG) {
const struct mpd_song *song = mpd_entity_get_song(entity);
int rating = db_get_song_rating(mpd_get_title(song),
mpd_get_artist(song));
if (rating < rating0) {
rating0 = rating;
sprintf(str, "%s", mpd_song_get_uri(song));
}
}
mpd_entity_free(entity);
}
}
void print_entity_list(struct mpd_connection *c, enum mpd_entity_type filter_type)
{
struct mpd_entity *entity;
while ((entity = mpd_recv_entity(c)) != NULL) {
const struct mpd_directory *dir;
const struct mpd_song *song;
const struct mpd_playlist *playlist;
enum mpd_entity_type type = mpd_entity_get_type(entity);
if (filter_type != MPD_ENTITY_TYPE_UNKNOWN &&
type != filter_type)
type = MPD_ENTITY_TYPE_UNKNOWN;
switch (type) {
case MPD_ENTITY_TYPE_UNKNOWN:
break;
case MPD_ENTITY_TYPE_DIRECTORY:
dir = mpd_entity_get_directory(entity);
printf("%s\n", mpd_directory_get_path(dir)); //charset_from_utf8(mpd_directory_get_path(dir)));
break;
case MPD_ENTITY_TYPE_SONG:
song = mpd_entity_get_song(entity);
/*if (options.custom_format) {
pretty_print_song(song);
puts("");
} else*/
printf("%s\n", mpd_song_get_uri(song)); //charset_from_utf8(mpd_song_get_uri(song)));
break;
case MPD_ENTITY_TYPE_PLAYLIST:
playlist = mpd_entity_get_playlist(entity);
printf("%s\n", mpd_playlist_get_path(playlist)); //charset_from_utf8(mpd_playlist_get_path(playlist)));
break;
}
mpd_entity_free(entity);
}
}
/**
* MPD stopped playing this song.
*/
void
song_ended(const struct mpd_song *song, bool love)
{
int elapsed = g_timer_elapsed(timer, NULL);
if (!played_long_enough(elapsed, mpd_song_get_duration(song)))
return;
/* FIXME:
libmpdclient doesn't have any way to fetch the musicbrainz id. */
as_songchange(mpd_song_get_uri(song),
mpd_song_get_tag(song, MPD_TAG_ARTIST, 0),
mpd_song_get_tag(song, MPD_TAG_TITLE, 0),
mpd_song_get_tag(song, MPD_TAG_ALBUM, 0),
mpd_song_get_tag(song, MPD_TAG_TRACK, 0),
mpd_song_get_tag(song, MPD_TAG_MUSICBRAINZ_TRACKID, 0),
mpd_song_get_duration(song) > 0
? mpd_song_get_duration(song)
: g_timer_elapsed(timer, NULL),
love,
NULL);
}
char* getFilename(Config* config, int status) {
if (!config->curr_song) {
return strdup("");
}
const char* uri = mpd_song_get_uri(config->curr_song);
if (!uri || uri[0] == 0) {
return strdup("");
}
const char* str = strrchr(uri, '/');
// check if more then the / is in the string
if (!str || strlen(str) < 2) {
str = uri;
}
str++;
return strdup(str);
}
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;
}
static int
love_song(struct mpdcron_connection *conn, bool love, const char *expr)
{
int changes;
char *esc_uri, *myexpr;
struct mpd_song *song;
if (expr != NULL) {
if (!mpdcron_love_expr(conn, love, expr, &changes)) {
eulog(LOG_ERR, "Failed to %s song: %s",
love ? "love" : "hate",
conn->error->message);
return 1;
}
}
else {
if ((song = load_current_song()) == NULL)
return 1;
esc_uri = quote(mpd_song_get_uri(song));
myexpr = g_strdup_printf("uri=%s", esc_uri);
g_free(esc_uri);
mpd_song_free(song);
if (!mpdcron_love_expr(conn, love, myexpr, &changes)) {
eulog(LOG_ERR, "Failed to %s current playing song: %s",
love ? "love" : "hate",
conn->error->message);
g_free(myexpr);
return 1;
}
g_free(myexpr);
}
printf("Modified %d entries\n", changes);
return 0;
}
/*
* pgmpc_playlist
* List all songs in given playlist. If not playlist is specified list
* songs of current playlist.
*/
Datum
pgmpc_playlist(PG_FUNCTION_ARGS)
{
TupleDesc tupdesc;
Tuplestorestate *tupstore;
char *playlist = NULL;
bool ret;
if (PG_NARGS() == 1 && !PG_ARGISNULL(0))
playlist = text_to_cstring(PG_GETARG_TEXT_PP(0));
/* Initialize function context */
pgmpc_init_setof_single(fcinfo, TEXTOID, "playlist", &tupdesc, &tupstore);
/*
* Run the command to get all the songs.
*/
pgmpc_init();
ret = playlist ?
mpd_send_list_playlist_meta(mpd_conn, playlist) :
mpd_send_list_queue_meta(mpd_conn);
if (!ret)
pgmpc_print_error();
/* Now get all the songs and send them back to caller */
while (true)
{
Datum values[1];
bool nulls[1];
struct mpd_song *song = mpd_recv_song(mpd_conn);
/* Leave if done */
if (song == NULL)
break;
/* Assign song name */
nulls[0] = false;
values[0] = CStringGetTextDatum(mpd_song_get_uri(song));
/* Save values */
tuplestore_putvalues(tupstore, tupdesc, values, nulls);
/* Clean up for the next one */
mpd_song_free(song);
}
/* We may be in error state, so check for it */
if (mpd_connection_get_error(mpd_conn) != MPD_ERROR_SUCCESS)
{
const char *message = mpd_connection_get_error_message(mpd_conn);
pgmpc_reset();
ereport(ERROR,
(errcode(ERRCODE_SYSTEM_ERROR),
errmsg("mpd command failed: %s",
message)));
}
/* Clean up */
pgmpc_reset();
/* clean up and return the tuplestore */
tuplestore_donestoring(tupstore);
return (Datum) 0;
}
int mpd_put_browse(char *buffer, char *path, unsigned int offset)
{
char *cur = buffer;
const char *end = buffer + MAX_SIZE;
struct mpd_entity *entity;
unsigned int entity_count = 0;
if (!mpd_send_list_meta(mpd.conn, path))
RETURN_ERROR_AND_RECOVER("mpd_send_list_meta");
cur += json_emit_raw_str(cur, end - cur, "{\"type\":\"browse\",\"data\":[ ");
while((entity = mpd_recv_entity(mpd.conn)) != NULL) {
const struct mpd_song *song;
const struct mpd_directory *dir;
const struct mpd_playlist *pl;
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;
}
switch (mpd_entity_get_type(entity)) {
case MPD_ENTITY_TYPE_UNKNOWN:
break;
case MPD_ENTITY_TYPE_SONG:
song = mpd_entity_get_song(entity);
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, ",\"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, "},");
break;
case MPD_ENTITY_TYPE_DIRECTORY:
dir = mpd_entity_get_directory(entity);
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, "},");
break;
case MPD_ENTITY_TYPE_PLAYLIST:
pl = mpd_entity_get_playlist(entity);
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, "},");
break;
}
mpd_entity_free(entity);
entity_count++;
}
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;
return 0;
}
/* remove last ',' */
cur--;
cur += json_emit_raw_str(cur, end - cur, "]}");
return cur - buffer;
}