/**
* @param mi A #MpdObj
* @param path an Path to a file
*
* Grabs the song info for a single file. Make sure you pass an url to a song
* and not a directory, that might result in strange behauviour.
*
* @returns a #mpd_Song
*/
mpd_Song * mpd_database_get_fileinfo(MpdObj *mi,const char *path)
{
mpd_Song *song = NULL;
mpd_InfoEntity *ent = NULL;
/*
* Check path for availibility and length
*/
if(path == NULL || path[0] == '\0')
{
debug_printf(DEBUG_ERROR, "path == NULL || strlen(path) == 0");
return NULL;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return NULL;
}
/* lock, so we can work on mi->connection */
if(mpd_lock_conn(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR, "Failed to lock connection");
return NULL;
}
/* send the request */
mpd_sendListallInfoCommand(mi->connection, path);
/* get the first (and only) result */
ent = mpd_getNextInfoEntity(mi->connection);
/* finish and clean up libmpdclient */
mpd_finishCommand(mi->connection);
/* unlock again */
if(mpd_unlock_conn(mi))
{
if(ent) mpd_freeInfoEntity(ent);
debug_printf(DEBUG_ERROR, "Failed to unlock");
return NULL;
}
if(ent == NULL)
{
debug_printf(DEBUG_ERROR, "Failed to grab song from mpd\n");
return NULL;
}
if(ent->type != MPD_INFO_ENTITY_TYPE_SONG)
{
mpd_freeInfoEntity(ent);
debug_printf(DEBUG_ERROR, "Failed to grab correct song type from mpd, path might not be a file\n");
return NULL;
}
/* get the song */
song = ent->info.song;
/* remove reference to song from the entity */
ent->info.song = NULL;
/* free the entity */
mpd_freeInfoEntity(ent);
return song;
}
/******************** Song ingo retrival ************************************/
static int getSong(void) {
mpd_Status *status;
mpd_InfoEntity *info;
/* Get status */
mpd_sendStatusCommand(D.conn);
if (error()) return 0;
status = mpd_getStatus(D.conn);
if (error()) return 0;
pdie_on(!status, "get status");
mpd_nextListOkCommand(D.conn);
if (error()) {
mpd_freeStatus(status);
return 0;
}
/* Copy status */
D.cur.state = status->state;
D.cur.songid = status->songid;
D.cur.pos = status->elapsedTime;
D.cur.len = status->totalTime;
mpd_freeStatus(status);
/* Same song, return */
if (D.cur.songid == D.old.songid) {
return 1;
}
if (D.info) {
mpd_freeInfoEntity(D.info);
D.info = 0;
}
/* Get song */
mpd_sendCurrentSongCommand(D.conn);
if (error()) {
return 0;
}
info = mpd_getNextInfoEntity(D.conn);
if (error()) {
return 0;
}
if (!info) {
return
D.cur.state == MPD_STATUS_STATE_PLAY ||
D.cur.state == MPD_STATUS_STATE_PAUSE;
}
if (info->type != MPD_INFO_ENTITY_TYPE_SONG) {
mpd_freeInfoEntity(info);
return 0;
}
D.info = info;
return 1;
}
/*
=================
MPD_Status - show info about currently playing song
=================
*/
void MPD_Status(void)
{
mpd_Status *status;
mpd_InfoEntity *entity = NULL;
mpd_Song *song = 0;
char title[MP3_MAXSONGTITLE];
if(!MP3_Status())
return;
mpd_sendStatusCommand(conn);
if( (status = mpd_getStatus(conn)) == NULL)
{
Com_Printf("MPD: %s\n", conn->errorStr);
mpd_finishCommand(conn);
return;
}
mpd_finishCommand(conn);
if( status->state == MPD_STATUS_STATE_STOP) {
/* Playback stopped */
Com_Printf("MPD: not playing\n");
mpd_freeStatus(status);
return;
}
if( status->state == MPD_STATUS_STATE_PLAY || MPD_STATUS_STATE_PAUSE )
{
mpd_sendCurrentSongCommand(conn);
while((entity = mpd_getNextInfoEntity(conn)))
{
if(entity->type != MPD_INFO_ENTITY_TYPE_SONG)
{
mpd_freeInfoEntity(entity);
continue;
}
song = entity->info.song;
if(song->title == NULL || song->artist == NULL)
Com_sprintf(title, sizeof(title), "%s [%i:%02i]", (song->title) ? song->title : song->file, status->totalTime / 60, status->totalTime % 60);
else
Com_sprintf(title, sizeof(title), "%s - %s [%i:%02i]", song->artist, song->title, status->totalTime / 60, status->totalTime % 60);
COM_MakePrintable(title);
Com_Printf("%s\n", title);
mpd_freeInfoEntity(entity);
break;
}
mpd_finishCommand(conn);
}
mpd_freeStatus(status);
}
void mpdGetSongTitle()
{
mpd_InfoEntity * entity;
mpd_sendCommandListOkBegin(conn);
mpd_sendStatusCommand(conn);
mpd_sendCurrentSongCommand(conn);
mpd_sendCommandListEnd(conn);
if((status = mpd_getStatus(conn))==NULL) {
fprintf(stderr,"%s\n",conn->errorStr);
mpd_closeConnection(conn);
}
songname = (char *)malloc(100);
mpd_nextListOkCommand(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
mpd_Song * song = entity->info.song;
if(entity->type!=MPD_INFO_ENTITY_TYPE_SONG) {
mpd_freeInfoEntity(entity);
continue;
}
if(song->artist) {
strcpy(songname, " [");
strcat(songname, song->artist);
strcat(songname, " - ");
}
if(song->album) {
strcat(songname, song->album);
strcat(songname, " - ");
}
if(song->title) {
songname = strcat(songname, song->title);
songname = strcat(songname, "] ");
}
mpd_freeInfoEntity(entity);
}
if(conn->error) {
fprintf(stderr,"%s\n",conn->errorStr);
mpd_closeConnection(conn);
}
mpd_finishCommand(conn);
if(conn->error) {
fprintf(stderr,"%s\n",conn->errorStr);
mpd_closeConnection(conn);
}
}
static int mpdclient_playlist_update(void *data) {
mpd_Status * status;
mpd_InfoEntity *entity;
int i;
mpd_sendCommandListOkBegin(conn);
mpd_sendStatusCommand(conn);
mpd_sendPlChangesCommand(conn, cur_playlist);
mpd_sendCommandListEnd(conn);
if((status = mpd_getStatus(conn))==NULL) {
fprintf(stderr,"%s\n",conn->errorStr);
mpd_closeConnection(conn);
return 1;
}
cur_playlist = status->playlist;
cur_song = status->songid;
mpd_nextListOkCommand(conn);
evas_event_freeze(evas);
while((entity = mpd_getNextInfoEntity(conn))) {
if(entity->type!=MPD_INFO_ENTITY_TYPE_SONG) {
mpd_freeInfoEntity(entity);
continue;
}
music_song_insert(entity->info.song);
mpd_freeInfoEntity(entity);
}
for (i = status->playlistLength; i < music_song_count(); i++) {
music_song_remove(i);
}
if (status->state == MPD_STATUS_STATE_PLAY ||
status->state == MPD_STATUS_STATE_PAUSE) {
music_song_update(status->song, status->totalTime);
} else {
music_song_update(-1, 0);
}
layout_update(status->state == MPD_STATUS_STATE_PLAY, status->volume);
evas_event_thaw(evas);
mpd_finishCommand(conn);
mpd_freeStatus(status);
return 1;
}
static char *MPD_SongTitle ( void )
{
mpd_Status *status;
mpd_InfoEntity *entity = NULL;
mpd_Song *song = 0;
static char title[MP3_MAXSONGTITLE];
title[0] = 0;
if(!MP3_Status())
return title;
mpd_sendCommandListOkBegin(conn);
mpd_sendStatusCommand(conn);
mpd_sendCurrentSongCommand(conn);
mpd_sendCommandListEnd(conn);
if( (status = mpd_getStatus(conn)) == NULL)
{
return title;
}
mpd_nextListOkCommand(conn);
while((entity = mpd_getNextInfoEntity(conn)))
{
if(entity->type != MPD_INFO_ENTITY_TYPE_SONG)
{
mpd_freeInfoEntity(entity);
continue;
}
song = entity->info.song;
if(song->title == NULL || song->artist == NULL)
Com_sprintf(title, sizeof(title), "%s [%i:%02i]", song->file, status->totalTime / 60, status->totalTime % 60);
else
Com_sprintf(title, sizeof(title), "%s - %s [%i:%02i]", song->artist, song->title, status->totalTime / 60, status->totalTime % 60);
COM_MakePrintable(title);
mpd_freeInfoEntity(entity);
break;
}
mpd_freeStatus(status);
mpd_finishCommand(conn);
return title;
}
/*******************************************************************************
* PLAYLIST
*/
mpd_Song * mpd_playlist_get_song(MpdObj *mi, int songid)
{
mpd_Song *song = NULL;
mpd_InfoEntity *ent = NULL;
if(songid < 0){
debug_printf(DEBUG_ERROR, "songid < 0 Failed");
return NULL;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
return NULL;
}
debug_printf(DEBUG_INFO, "Trying to grab song with id: %i\n", songid);
mpd_sendPlaylistIdCommand(mi->connection, songid);
ent = mpd_getNextInfoEntity(mi->connection);
mpd_finishCommand(mi->connection);
if(mpd_unlock_conn(mi))
{
if(ent) mpd_freeInfoEntity(ent);
return NULL;
}
if(ent == NULL)
{
debug_printf(DEBUG_ERROR, "Failed to grab song from mpd\n");
return NULL;
}
if(ent->type != MPD_INFO_ENTITY_TYPE_SONG)
{
mpd_freeInfoEntity(ent);
debug_printf(DEBUG_ERROR, "Failed to grab correct song type from mpd\n");
return NULL;
}
song = ent->info.song;
ent->info.song = NULL;
mpd_freeInfoEntity(ent);
return song;
}
int
cmd_playlist(mpd_unused int argc, mpd_unused char **argv, mpd_Connection *conn)
{
mpd_InfoEntity * entity;
mpd_Status * status;
int count = 0;
mpd_sendStatusCommand(conn);
printErrorAndExit(conn);
status = mpd_getStatus(conn);
printErrorAndExit(conn);
mpd_finishCommand(conn);
mpd_sendPlaylistInfoCommand(conn,-1);
printErrorAndExit(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
if(entity->type==MPD_INFO_ENTITY_TYPE_SONG) {
struct mpd_song *song = entity->info.song;
printf("%s%i) ", (status->song == count)?">":" ", 1+count);
pretty_print_song(song);
printf("\n");
count++;
}
mpd_freeInfoEntity(entity);
}
my_finishCommand(conn);
mpd_freeStatus(status);
return 0;
}
int cmd_tab ( int argc, char ** argv, mpd_Connection * conn )
{
mpd_InfoEntity * entity;
struct mpd_song *song;
mpd_sendListallCommand(conn,"");
printErrorAndExit(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
if(entity->type==MPD_INFO_ENTITY_TYPE_SONG) {
song = entity->info.song;
if(argc==1) {
if(strncmp(song->file,argv[0],
strlen(argv[0]))==0) {
printf("%s\n",
charset_from_utf8(song->file));
}
} else
printf("%s\n", charset_from_utf8(song->file));
}
mpd_freeInfoEntity(entity);
}
my_finishCommand(conn);
return 0;
}
int cmd_ls ( int argc, char ** argv, mpd_Connection * conn )
{
mpd_InfoEntity * entity;
const char *ls;
int i = 0;
if (argc > 0)
ls = charset_to_utf8(argv[i]);
else
ls = strdup("");
do {
mpd_sendLsInfoCommand(conn,ls);
printErrorAndExit(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
if(entity->type==MPD_INFO_ENTITY_TYPE_DIRECTORY) {
mpd_Directory * dir = entity->info.directory;
printf("%s\n", charset_from_utf8(dir->path));
}
else if(entity->type==MPD_INFO_ENTITY_TYPE_SONG) {
struct mpd_song *song = entity->info.song;
printf("%s\n", charset_from_utf8(song->file));
}
mpd_freeInfoEntity(entity);
}
my_finishCommand(conn);
} while (++i < argc && (ls = charset_to_utf8(argv[i])) != NULL);
return 0;
}
int cmd_lsplaylists ( int argc, char ** argv, mpd_Connection * conn )
{
mpd_InfoEntity * entity;
const char * ls = "";
int i = 0;
if(argc>0) ls = charset_to_utf8(argv[i]);
do {
mpd_sendLsInfoCommand(conn,ls);
printErrorAndExit(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
if(entity->type==
MPD_INFO_ENTITY_TYPE_PLAYLISTFILE) {
mpd_PlaylistFile * pl = entity->info.playlistFile;
printf("%s\n", charset_from_utf8(pl->path));
}
mpd_freeInfoEntity(entity);
}
my_finishCommand(conn);
} while (++i < argc && (ls = charset_to_utf8(argv[i])) != NULL);
return 0;
}
int cmd_lstab ( int argc, char ** argv, mpd_Connection * conn )
{
mpd_InfoEntity * entity;
mpd_Directory * dir;
mpd_sendListallCommand(conn,"");
printErrorAndExit(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
if(entity->type==MPD_INFO_ENTITY_TYPE_DIRECTORY) {
dir = entity->info.directory;
if(argc==1) {
if(strncmp(dir->path,argv[0],
strlen(argv[0]))==0) {
printf("%s\n",
charset_from_utf8(dir->path));
}
}
}
mpd_freeInfoEntity(entity);
}
my_finishCommand(conn);
return 0;
}
int cmd_loadtab ( int argc, char ** argv, mpd_Connection * conn )
{
mpd_InfoEntity * entity;
char * sp;
mpd_PlaylistFile * pl;
mpd_sendLsInfoCommand(conn,"");
printErrorAndExit(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
if(entity->type==MPD_INFO_ENTITY_TYPE_PLAYLISTFILE) {
pl = entity->info.playlistFile;
sp = pl->path;
while((sp = strchr(sp,' '))) *sp = '_';
if(argc==1) {
if(strncmp(pl->path,argv[0],
strlen(argv[0]))==0) {
printf("%s\n",
charset_from_utf8(pl->path));
}
}
}
mpd_freeInfoEntity(entity);
}
my_finishCommand(conn);
return 0;
}
int cmd_current(mpd_unused int argc, mpd_unused char ** argv, mpd_Connection *conn)
{
mpd_Status * status;
mpd_InfoEntity * entity;
mpd_sendCommandListOkBegin(conn);
printErrorAndExit(conn);
mpd_sendStatusCommand(conn);
printErrorAndExit(conn);
mpd_sendCurrentSongCommand(conn);
printErrorAndExit(conn);
mpd_sendCommandListEnd(conn);
printErrorAndExit(conn);
status = mpd_getStatus(conn);
printErrorAndExit(conn);
if (status->state == MPD_STATUS_STATE_PLAY ||
status->state == MPD_STATUS_STATE_PAUSE) {
mpd_nextListOkCommand(conn);
printErrorAndExit(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
struct mpd_song *song = entity->info.song;
if(entity->type!=MPD_INFO_ENTITY_TYPE_SONG) {
mpd_freeInfoEntity(entity);
continue;
}
pretty_print_song(song);
printf("\n");
mpd_freeInfoEntity(entity);
break;
}
printErrorAndExit(conn);
mpd_finishCommand(conn);
printErrorAndExit(conn);
}
mpd_freeStatus(status);
return 0;
}
MpdData *mpd_database_get_playlist_content(MpdObj *mi,char *playlist)
{
MpdData *data = NULL;
mpd_InfoEntity *ent = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(!mpd_server_check_version(mi, 0,12,0))
{
debug_printf(DEBUG_WARNING, "only works with mpd higher then 0.12.0");
return NULL;
}
if(mpd_server_check_command_allowed(mi, "listplaylistinfo") != MPD_SERVER_COMMAND_ALLOWED)
{
debug_printf(DEBUG_WARNING, "Listing playlist content not supported or allowed");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING,"lock failed\n");
return NULL;
}
mpd_sendListPlaylistInfoCommand(mi->connection, playlist);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
data = mpd_new_data_struct_append( data );
if(ent->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
{
data->type = MPD_DATA_TYPE_DIRECTORY;
data->directory = ent->info.directory->path;
ent->info.directory->path = NULL;
}
else if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
else if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
{
data->type = MPD_DATA_TYPE_PLAYLIST;
data->playlist = ent->info.playlistFile->path;
ent->info.playlistFile->path = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
MpdData * mpd_database_get_directory(MpdObj *mi,char *path)
{
MpdData *data = NULL;
mpd_InfoEntity *ent = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(path == NULL)
{
path = "/";
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING,"lock failed\n");
return NULL;
}
mpd_sendLsInfoCommand(mi->connection,path);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
data = mpd_new_data_struct_append(data);
if(ent->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
{
data->type = MPD_DATA_TYPE_DIRECTORY;
data->directory = ent->info.directory->path;
ent->info.directory->path = NULL;
}
else if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
else if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
{
data->type = MPD_DATA_TYPE_PLAYLIST;
data->playlist = ent->info.playlistFile->path;
ent->info.playlistFile->path = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
MpdData * mpd_playlist_get_changes_posid(MpdObj *mi,int old_playlist_id)
{
MpdData *data = NULL;
mpd_InfoEntity *ent = NULL;
debug_printf(DEBUG_INFO, "Fetching using new plchangesposid command");
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING,"lock failed\n");
return NULL;
}
if(old_playlist_id == -1)
{
debug_printf(DEBUG_INFO,"get fresh playlist\n");
mpd_sendPlChangesPosIdCommand (mi->connection, 0);
/* mpd_sendPlaylistIdCommand(mi->connection, -1); */
}
else
{
mpd_sendPlChangesPosIdCommand (mi->connection, old_playlist_id);
}
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/* unlock */
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_WARNING,"mpd_playlist_get_changes: unlock failed.\n");
mpd_data_free(data);
return NULL;
}
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
static void disconnectFromMPD(void) {
if (D.conn) {
mpd_closeConnection(D.conn);
D.conn = 0;
}
if (D.info) {
mpd_freeInfoEntity(D.info);
D.info = 0;
}
D.cur.songid = -1;
D.old.songid = -1;
}
MpdData * mpd_playlist_search_commit(MpdObj *mi)
{
mpd_InfoEntity *ent = NULL;
MpdData *data = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(mi->search_type < MPD_SEARCH_TYPE_PLAYLIST_FIND )
{
debug_printf(DEBUG_ERROR, "no or wrong search in progress to commit");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return NULL;
}
mpd_commitSearch(mi->connection);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/*
* reset search type
*/
mi->search_type = MPD_SEARCH_TYPE_NONE;
mi->search_field = MPD_TAG_ITEM_ARTIST;
/* unlock */
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_ERROR, "Failed to unlock connection");
if(data)mpd_data_free(data);
return NULL;
}
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
MpdData * mpd_playlist_get_song_from_pos_range(MpdObj *mi, int start, int stop)
{
MpdData *data = NULL;
int i;
mpd_InfoEntity *ent = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return NULL;
}
if(mpd_status_check(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR,"Failed grabbing status\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
return NULL;
}
/* Don't check outside playlist length */
if(!(stop < mi->status->playlistLength)) {
stop = mi->status->playlistLength -1;
}
mpd_sendCommandListBegin(mi->connection);
for(i=start; i <= stop; i++){
mpd_sendPlaylistInfoCommand(mi->connection, i);
}
mpd_sendCommandListEnd(mi->connection);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
if(mpd_unlock_conn(mi))
{
/*TODO free entity. for now this can never happen */
return NULL;
}
return data;
}
int main(int argc, char ** argv) {
char *string;
mpd_Connection * conn;
conn = mpd_newConnection("192.150.0.108",6600,10);
if(conn->error) {
fprintf(stderr,"%s\n",conn->errorStr);
mpd_closeConnection(conn);
return -1;
}
int i=0;
// for(i=0;i<1000;i++)
// {
/*/
mpd_sendCommandsCommand(conn);
while (( string = mpd_getNextCommand(conn)) != NULL)
{
//printf("%s\n", string);
free(string);
}
mpd_finishCommand(conn);
*/
// }
//
//
//
//
for(i=0;i<100;i++)
{
mpd_sendPlChangesCommand(conn,0);
mpd_InfoEntity *ent = NULL;
while((ent = mpd_getNextInfoEntity(conn)) != NULL){
// printf("%s\n", ent->info.song->artist);
mpd_freeInfoEntity(ent);
}
}
mpd_closeConnection(conn);
return 0;
}
MPDEntities MPDConnection::entities() const {
ASSERT;
MPDEntities ret;
for (mpd_InfoEntity *entity; (entity = mpd_getNextInfoEntity(d->connection)) != NULL; ) {
if (entity->type == MPD_INFO_ENTITY_TYPE_SONG) {
ret.appendSong(MPDSong(entity));
} else if (entity->type == MPD_INFO_ENTITY_TYPE_DIRECTORY) {
ret.appendDirectory(QString::fromUtf8(entity->info.directory->path));
} else if (entity->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE) {
ret.appendPlaylist(MPDSong(entity));
} else {
qWarning("MPDConnection::availableEntities() Unknown entity type: %d", entity->type);
}
mpd_freeInfoEntity(entity);
}
return ret;
}
int cmd_load ( int argc, char ** argv, mpd_Connection * conn )
{
int i;
char * sp;
char * dp;
mpd_InfoEntity * entity;
mpd_PlaylistFile * pl;
for(i=0;i<argc;i++) {
sp = argv[i];
while((sp = strchr(sp,' '))) *sp = '_';
}
mpd_sendLsInfoCommand(conn,"");
printErrorAndExit(conn);
while((entity = mpd_getNextInfoEntity(conn))) {
if(entity->type==MPD_INFO_ENTITY_TYPE_PLAYLISTFILE) {
pl = entity->info.playlistFile;
dp = sp = strdup(charset_from_utf8(pl->path));
while((sp = strchr(sp,' '))) *sp = '_';
for(i=0;i<argc;i++) {
if(strcmp(dp,argv[i])==0)
strcpy(argv[i], charset_from_utf8(pl->path));
}
free(dp);
mpd_freeInfoEntity(entity);
}
}
my_finishCommand(conn);
mpd_sendCommandListBegin(conn);
printErrorAndExit(conn);
for(i=0;i<argc;i++) {
printf("loading: %s\n",argv[i]);
mpd_sendLoadCommand(conn,charset_to_utf8(argv[i]));
printErrorAndExit(conn);
}
mpd_sendCommandListEnd(conn);
my_finishCommand(conn);
return 0;
}
MpdData * mpd_database_get_directory_recursive(MpdObj *mi, const char *path)
{
MpdData *data = NULL;
mpd_InfoEntity *ent = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(path == '\0' || path[0] == '\0')
{
debug_printf(DEBUG_ERROR, "argumant invalid\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return NULL;
}
mpd_sendListallInfoCommand(mi->connection,path);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
void MpdClient::updatePlaylist(long long version)
{
if (version < 0)
mpd_sendPlChangesCommand(conn, version);
else
mpd_sendPlaylistInfoCommand(conn, -1);
mpd_InfoEntity *entity;
while ((entity = mpd_getNextInfoEntity(conn))) {
assert(entity->type == MPD_INFO_ENTITY_TYPE_SONG);
mpd_Song *song = mpd_songDup(entity->info.song);
mpd_freeInfoEntity(entity);
assert(song->pos <= playlist.size());
if (song->pos == playlist.size())
playlist += song;
else {
mpd_freeSong(playlist[song->pos]);
playlist[song->pos] = song;
}
emit(changedSong(song));
}
mpd_finishCommand(conn);
/* remove extra songs if the playlist was shortened */
for (int i = playlist.size() - 1; i >= status->playlistLength; i--) {
mpd_freeSong(playlist[i]);
playlist.removeAt(i);
emit(changedSong(NULL));
}
}
static void *update_mpd_thread(void *arg)
{
static mpd_Connection *conn = NULL;
mpd_Status *status;
mpd_InfoEntity *entity;
timed_thread *me = *(timed_thread **)arg;
const char *emptystr = "";
while (1) {
if (!conn)
conn = mpd_newConnection(mpd_host, mpd_port, 10);
if (*mpd_password) {
mpd_sendPasswordCommand(conn, mpd_password);
mpd_finishCommand(conn);
}
timed_thread_lock(me);
if (conn->error || conn == NULL) {
NORM_ERR("MPD error: %s\n", conn->errorStr);
mpd_closeConnection(conn);
conn = 0;
clear_mpd();
mpd_info.status = "MPD not responding";
timed_thread_unlock(me);
if (timed_thread_test(me, 0)) {
timed_thread_exit(me);
}
continue;
}
mpd_sendStatusCommand(conn);
if ((status = mpd_getStatus(conn)) == NULL) {
NORM_ERR("MPD error: %s\n", conn->errorStr);
mpd_closeConnection(conn);
conn = 0;
clear_mpd();
mpd_info.status = "MPD not responding";
timed_thread_unlock(me);
if (timed_thread_test(me, 0)) {
timed_thread_exit(me);
}
continue;
}
mpd_finishCommand(conn);
if (conn->error) {
// fprintf(stderr, "%s\n", conn->errorStr);
mpd_closeConnection(conn);
conn = 0;
timed_thread_unlock(me);
if (timed_thread_test(me, 0)) {
timed_thread_exit(me);
}
continue;
}
mpd_info.vol = status->volume;
if (status->random == 0) {
mpd_info.random = "Off";
} else if (status->random == 1) {
mpd_info.random = "On";
} else {
mpd_info.random = "";
}
if (status->repeat == 0) {
mpd_info.repeat = "Off";
} else if (status->repeat == 1) {
mpd_info.repeat = "On";
} else {
mpd_info.repeat = "";
}
/* if (status->error) {
printf("error: %s\n", status->error);
} */
switch (status->state) {
case MPD_STATUS_STATE_PLAY:
mpd_info.status = "Playing";
break;
case MPD_STATUS_STATE_STOP:
mpd_info.status = "Stopped";
break;
case MPD_STATUS_STATE_PAUSE:
mpd_info.status = "Paused";
break;
default:
mpd_info.status = "";
clear_mpd();
break;
}
if (status->state == MPD_STATUS_STATE_PLAY ||
status->state == MPD_STATUS_STATE_PAUSE) {
mpd_info.is_playing = 1;
mpd_info.bitrate = status->bitRate;
mpd_info.progress = (float) status->elapsedTime /
status->totalTime;
mpd_info.elapsed = status->elapsedTime;
mpd_info.length = status->totalTime;
} else {
mpd_info.progress = 0;
mpd_info.is_playing = 0;
mpd_info.elapsed = 0;
}
if (conn->error) {
// fprintf(stderr, "%s\n", conn->errorStr);
mpd_closeConnection(conn);
conn = 0;
timed_thread_unlock(me);
if (timed_thread_test(me, 0)) {
timed_thread_exit(me);
}
continue;
}
mpd_sendCurrentSongCommand(conn);
while ((entity = mpd_getNextInfoEntity(conn))) {
mpd_Song *song = entity->info.song;
if (entity->type != MPD_INFO_ENTITY_TYPE_SONG) {
mpd_freeInfoEntity(entity);
continue;
}
#define SONGSET(x) { \
free(mpd_info.x); \
if(song->x) \
mpd_info.x = strmdup(song->x); \
else \
mpd_info.x = strmdup(emptystr); \
}
SONGSET(artist);
SONGSET(albumartist);
SONGSET(album);
SONGSET(title);
SONGSET(date);
SONGSET(track);
SONGSET(name);
SONGSET(file);
#undef SONGSET
if (entity != NULL) {
mpd_freeInfoEntity(entity);
entity = NULL;
}
}
mpd_finishCommand(conn);
if (conn->error) {
// fprintf(stderr, "%s\n", conn->errorStr);
mpd_closeConnection(conn);
conn = 0;
timed_thread_unlock(me);
if (timed_thread_test(me, 0)) {
timed_thread_exit(me);
}
continue;
}
timed_thread_unlock(me);
if (conn->error) {
// fprintf(stderr, "%s\n", conn->errorStr);
mpd_closeConnection(conn);
conn = 0;
if (timed_thread_test(me, 0)) {
timed_thread_exit(me);
}
continue;
}
mpd_freeStatus(status);
/* if (conn) {
mpd_closeConnection(conn);
conn = 0;
} */
if (timed_thread_test(me, 0)) {
timed_thread_exit(me);
}
continue;
}
/* never reached */
}
/* should be called mpd_database_find */
MpdData * mpd_database_find(MpdObj *mi, int table, char *string, int exact)
{
MpdData *data = NULL;
/* MpdData *artist = NULL;
MpdData *album = NULL;
*/ mpd_InfoEntity *ent = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING,"lock failed\n");
return NULL;
}
if(exact)
{
mpd_sendFindCommand(mi->connection,table,string);
}
else
{
mpd_sendSearchCommand(mi->connection, table,string);
}
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
data = mpd_new_data_struct_append(data);
/* mpd_sendSearch|Find only returns songs */
/*
if(ent->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
{
data->type = MPD_DATA_TYPE_DIRECTORY;
data->directory = ent->info.directory->path;
ent->info.directory->path = NULL;
}
else*/ if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
/* This is something the client can and should do */
/* if(data->song->artist != NULL)
{
int found = FALSE;
if(artist != NULL)
{
MpdData *fartist = mpd_data_get_first(artist);
do{
if( (fartist->type == MPD_DATA_TYPE_TAG) && (fartist->tag_type == MPD_TAG_ITEM_ARTIST))
{
if(fartist->tag == NULL)
{
printf("crap this should'nt be \n");
}
if(!strcmp(fartist->tag, data->song->artist))
{
found = TRUE;
}
}
fartist = mpd_data_get_next_real(fartist, FALSE);
}while(fartist && !found);
}
if(!found)
{
artist= mpd_new_data_struct_append(artist);
artist->type = MPD_DATA_TYPE_TAG;
artist->tag_type = MPD_TAG_ITEM_ARTIST;
artist->tag = strdup(data->song->artist);
}
}
if(data->song->album != NULL)
{
int found = FALSE;
if(album != NULL)
{
MpdData *falbum = mpd_data_get_first(album);
do{
if( (falbum->type == MPD_DATA_TYPE_TAG) && (falbum->tag_type == MPD_TAG_ITEM_ALBUM))
{
if(falbum->tag == NULL)
{
printf("crap this should'nt be \n");
}
if(!strcmp(falbum->tag, data->song->album))
{
found = TRUE;
}
}
falbum = mpd_data_get_next_real(falbum, FALSE);
}while(falbum && !found);
}
if(!found)
{
album = mpd_new_data_struct_append(album);
album->type = MPD_DATA_TYPE_TAG;
album->tag_type = MPD_TAG_ITEM_ALBUM;
album->tag = strdup(data->song->album);
}
}
*/
}
/*
else if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
{
data->type = MPD_DATA_TYPE_PLAYLIST;
data->playlist = ent->info.playlistFile->path;
ent->info.playlistFile->path = NULL;
}
*/
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
data = mpd_data_get_first(data);
/* prepend the album then artists*/
/* if(album != NULL)
{
if(data){
data = mpd_data_concatenate( album, data);
}else{
data = album;
}
}
if(artist != NULL)
{
if(data) {
album = mpd_data_concatenate( artist, data );
}else{
data = artist;
}
}
*/
return mpd_data_get_first(data);
}
static void
_mpdule_update_song (Instance * inst)
{
mpd_Connection *mpd;
Evas_Object *mpdule;
Evas_Object *o_popup;
if (!inst->mpd)
return;
mpd = inst->mpd;
mpdule = inst->mpdule;
o_popup = inst->o_popup;
mpd_sendStatusCommand (mpd);
if (mpd->error == 0)
{
mpd_Status *status = mpd_getStatus (mpd);
if (status)
{
if (status->state == MPD_STATUS_STATE_UNKNOWN)
{
edje_object_part_text_set (mpdule, "mpdule.status",
D_ ("Unknown"));
edje_object_part_text_set (o_popup, "mpdule.status",
D_ ("Unknown"));
}
else if (status->state == MPD_STATUS_STATE_STOP)
{
edje_object_part_text_set (mpdule, "mpdule.status",
D_ ("Stopped"));
edje_object_part_text_set (o_popup, "mpdule.status",
D_ ("Stopped"));
}
else if (status->state == MPD_STATUS_STATE_PLAY)
{
edje_object_part_text_set (mpdule, "mpdule.status",
D_ ("Playing"));
edje_object_part_text_set (o_popup, "mpdule.status",
D_ ("Playing"));
}
else if (status->state == MPD_STATUS_STATE_PAUSE)
{
edje_object_part_text_set (mpdule, "mpdule.status",
D_ ("Paused"));
edje_object_part_text_set (o_popup, "mpdule.status",
D_ ("Paused"));
}
if (status->state > MPD_STATUS_STATE_STOP)
{
mpd_sendCurrentSongCommand (mpd);
mpd_InfoEntity *entity = NULL;
while ((entity = mpd_getNextInfoEntity (mpd)))
{
if (entity->type == MPD_INFO_ENTITY_TYPE_SONG &&
entity->info.song->id == status->songid)
{
mpd_Song *song = entity->info.song;
if (song->artist)
{
edje_object_part_text_set (mpdule, "mpdule.artist",
song->artist);
edje_object_part_text_set (o_popup, "mpdule.artist",
song->artist);
}
else
{
edje_object_part_text_set (mpdule, "mpdule.artist",
"");
edje_object_part_text_set (o_popup, "mpdule.artist",
"");
}
if (song->title)
{
edje_object_part_text_set (mpdule, "mpdule.title",
song->title);
edje_object_part_text_set (o_popup, "mpdule.title",
song->title);
}
else
{
edje_object_part_text_set (mpdule, "mpdule.title",
"");
edje_object_part_text_set (o_popup, "mpdule.title",
"");
}
if (song->album)
{
edje_object_part_text_set (mpdule, "mpdule.album",
song->album);
edje_object_part_text_set (o_popup, "mpdule.album",
song->album);
}
else
{
edje_object_part_text_set (mpdule, "mpdule.album",
"");
edje_object_part_text_set (o_popup, "mpdule.album",
"");
}
if (song->track)
{
edje_object_part_text_set (mpdule, "mpdule.track",
song->track);
edje_object_part_text_set (o_popup, "mpdule.track",
song->track);
}
else
{
edje_object_part_text_set (mpdule, "mpdule.track",
"");
edje_object_part_text_set (o_popup, "mpdule.track",
"");
}
if (song->date)
{
edje_object_part_text_set (mpdule, "mpdule.date",
song->date);
edje_object_part_text_set (o_popup, "mpdule.date",
song->date);
}
else
{
edje_object_part_text_set (mpdule, "mpdule.date",
"");
edje_object_part_text_set (o_popup, "mpdule.date",
"");
}
if (song->genre)
{
edje_object_part_text_set (mpdule, "mpdule.genre",
song->genre);
edje_object_part_text_set (o_popup, "mpdule.genre",
song->genre);
}
else
{
edje_object_part_text_set (mpdule, "mpdule.genre",
"");
edje_object_part_text_set (o_popup, "mpdule.genre",
"");
}
if (song->composer)
{
edje_object_part_text_set (mpdule,
"mpdule.composer",
song->composer);
edje_object_part_text_set (o_popup,
"mpdule.composer",
song->composer);
}
else
{
edje_object_part_text_set (mpdule,
"mpdule.composer", "");
edje_object_part_text_set (o_popup,
"mpdule.composer", "");
}
if (song->time)
{
//char * songtime;
//sprintf(songtime, "%i", song->time);
//edje_object_part_text_set (mpdule, "mpdule.time", songtime);
//edje_object_part_text_set (o_popup, "mpdule.time", songtime);
}
else
{
edje_object_part_text_set (mpdule, "mpdule.time",
"");
edje_object_part_text_set (o_popup, "mpdule.time",
"");
}
if (song->file)
{
edje_object_part_text_set (mpdule, "mpdule.file",
song->file);
edje_object_part_text_set (o_popup, "mpdule.file",
song->file);
}
else
{
edje_object_part_text_set (mpdule, "mpdule.file",
"");
edje_object_part_text_set (o_popup, "mpdule.file",
"");
}
}
mpd_freeInfoEntity (entity);
}
}
mpd_freeStatus (status);
}
}
else
{
_mpdule_disconnect (inst);
_mpdule_connect (inst);
}
}
MpdData *mpd_database_token_find(MpdObj *mi , char *string)
{
MpdData *data = NULL;
mpd_InfoEntity *ent = NULL;
regex_t ** strdata = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return NULL;
}
if(string == NULL || !strlen(string) )
{
debug_printf(DEBUG_INFO, "no string found");
mpd_unlock_conn(mi);
return NULL;
}
else{
strdata = mpd_misc_tokenize(string);
}
if(strdata == NULL)
{
mpd_unlock_conn(mi);
debug_printf(DEBUG_INFO, "no split string found");
return NULL;
}
mpd_sendListallInfoCommand(mi->connection, "/");
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
int i = 0;
int match = 0;
int loop = 1;
for(i=0; strdata[i] != NULL && loop; i++)
{
match = 0;
if(ent->info.song->file && !regexec(strdata[i],ent->info.song->file, 0, NULL, 0))
{
match = 1;
}
else if(ent->info.song->artist && !regexec(strdata[i],ent->info.song->artist, 0, NULL, 0))
{
match = 1;
}
else if(ent->info.song->title && !regexec(strdata[i],ent->info.song->title, 0, NULL, 0))
{
match = 1;
}
else if(ent->info.song->album && !regexec(strdata[i],ent->info.song->album, 0, NULL, 0))
{
match = 1;
}
if(!match)
{
loop = 0;
}
}
if(match)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_SONG;
/*
data->song = mpd_songDup(ent->info.song);
*/
data->song = ent->info.song;
ent->info.song = NULL;
}
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
mpd_misc_tokens_free(strdata);
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}