MpdDBStats * mpd_database_search_stats_commit(MpdObj *mi) { MpdDBStats *data = NULL; if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return NULL; } if(mi->search_type != MPD_SEARCH_TYPE_STATS) { debug_printf(DEBUG_ERROR, "no/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); data = (MpdDBStats *) mpd_getSearchStats(mi->connection); /* unlock */ if(mpd_unlock_conn(mi)) { debug_printf(DEBUG_ERROR, "Failed to unlock connection"); if(data)mpd_freeSearchStats((mpd_SearchStats *)data); return NULL; } if(data == NULL) { return NULL; } return data; }
int mpd_sticker_song_set(MpdObj *mi, const char *path, const char *tag, const char *value) { if(!mpd_check_connected(mi)) { debug_printf(DEBUG_INFO,"not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_server_check_command_allowed(mi, "sticker") != MPD_SERVER_COMMAND_ALLOWED) { debug_printf(DEBUG_WARNING, "Command not allowed\n"); return MPD_SERVER_NOT_SUPPORTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendSetSongSticker(mi->connection,path, tag,value); mpd_finishCommand(mi->connection); if(mpd_unlock_conn(mi)) { debug_printf(DEBUG_ERROR, "Failed to unlock"); return MPD_LOCK_FAILED; } return MPD_OK; }
int mpd_database_save_playlist(MpdObj *mi, char *name) { if(name == NULL || !strlen(name)) { debug_printf(DEBUG_WARNING, "mpd_playlist_save: name != NULL and strlen(name) > 0 failed"); return MPD_ARGS_ERROR; } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"mpd_playlist_save: not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"mpd_playlist_save: lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendSaveCommand(mi->connection,name); mpd_finishCommand(mi->connection); if(mi->connection->error == MPD_ERROR_ACK && mi->connection->errorCode == MPD_ACK_ERROR_EXIST) { mpd_clearError(mi->connection); mpd_unlock_conn(mi); return MPD_DATABASE_PLAYLIST_EXIST; } /* unlock */ mpd_unlock_conn(mi); return MPD_OK; }
int mpd_database_delete_playlist(MpdObj *mi,char *path) { if(path == NULL) { debug_printf(DEBUG_WARNING, "path == NULL"); return MPD_ARGS_ERROR; } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendRmCommand(mi->connection,path); mpd_finishCommand(mi->connection); /* unlock */ mpd_unlock_conn(mi); return MPD_OK; }
int mpd_database_update_dir(MpdObj *mi, char *path) { /* if(path == NULL || !strlen(path)) { debug_printf(DEBUG_ERROR, "path != NULL and strlen(path) > 0 failed"); return MPD_ARGS_ERROR; } */ if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendUpdateCommand(mi->connection,path); mpd_finishCommand(mi->connection); /* I have no idea why do this ?? it even makes gmpc very very unhappy. * Because it doesnt trigger an signal anymore when updating starts * mi->CurrentState.updatingDb = mpd_getUpdateId(mi->connection); */ /* unlock */ mpd_unlock_conn(mi); /* What I think you should do is to force a direct status updated */ mpd_status_update(mi); return MPD_OK; }
int mpd_playlist_queue_commit(MpdObj *mi) { if(mi->queue == NULL) { debug_printf(DEBUG_WARNING,"mi->queue is empty"); return MPD_PLAYLIST_QUEUE_EMPTY; } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_WARNING,"lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendCommandListBegin(mi->connection); /* get first item */ mi->queue = mi->queue->first; while(mi->queue != NULL) { if(mi->queue->type == MPD_QUEUE_ADD) { if(mi->queue->path != NULL) { mpd_sendAddCommand(mi->connection, mi->queue->path); } } else if(mi->queue->type == MPD_QUEUE_LOAD) { if(mi->queue->path != NULL) { mpd_sendLoadCommand(mi->connection, mi->queue->path); } } else if (mi->queue->type == MPD_QUEUE_DELETE_ID) { if(mi->queue->id >= 0) { mpd_sendDeleteIdCommand(mi->connection, mi->queue->id); } } else if (mi->queue->type == MPD_QUEUE_DELETE_POS) { if(mi->queue->id >= 0) { mpd_sendDeleteCommand(mi->connection, mi->queue->id); } } mpd_queue_get_next(mi); } mpd_sendCommandListEnd(mi->connection); mpd_finishCommand(mi->connection); mpd_unlock_conn(mi); mpd_status_update(mi); return MPD_OK; }
int mpd_server_set_output_device(MpdObj *mi,int device_id,int state) { if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } if(state) { mpd_sendEnableOutputCommand(mi->connection, device_id); } else { mpd_sendDisableOutputCommand(mi->connection, device_id); } mpd_finishCommand(mi->connection); mpd_unlock_conn(mi); mpd_status_queue_update(mi); return FALSE; }
int mpd_player_pause(MpdObj * mi) { if (!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING, "not connected\n"); return MPD_NOT_CONNECTED; } if (mpd_lock_conn(mi)) { debug_printf(DEBUG_WARNING, "lock failed\n"); return MPD_LOCK_FAILED; } if (mpd_player_get_state(mi) == MPD_PLAYER_PAUSE) { mpd_sendPauseCommand(mi->connection, 0); mpd_finishCommand(mi->connection); } else if (mpd_player_get_state(mi) == MPD_PLAYER_PLAY) { mpd_sendPauseCommand(mi->connection, 1); mpd_finishCommand(mi->connection); } mpd_unlock_conn(mi); if (mpd_status_update(mi)) { return MPD_STATUS_FAILED; } return MPD_OK; }
int mpd_send_password(MpdObj *mi) { if(!mi) return MPD_ARGS_ERROR; if(mi->password && mpd_check_connected(mi) && strlen(mi->password)) { if(mpd_lock_conn(mi)) { debug_printf(DEBUG_WARNING, "failed to lock connection"); return MPD_LOCK_FAILED; } mpd_sendPasswordCommand(mi->connection, mi->password); mpd_finishCommand(mi->connection); if(mpd_unlock_conn(mi)) { debug_printf(DEBUG_ERROR, "Failed to unlock connection\n"); return MPD_LOCK_FAILED; } mpd_server_get_allowed_commands(mi); /*TODO: should I do it here, or in the * mpd_server_get_allowed_command, so it also get's executed on * connect */ if((mi->the_status_changed_callback != NULL)) { mi->the_status_changed_callback( mi, MPD_CST_PERMISSION, mi->the_status_changed_signal_userdata ); } } return MPD_OK; }
void mpd_playlist_search_start(MpdObj *mi, int exact) { /* * Check argument */ if(mi == NULL || exact > 1 || exact < 0) { debug_printf(DEBUG_ERROR, "Argument error"); return ; } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_ERROR, "Not Connected\n"); return ; } if(!mpd_server_check_version(mi, 0,12,1)) { debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.2 or higher"); return ; } /* lock, so we can work on mi->connection */ if(mpd_lock_conn(mi) != MPD_OK) { debug_printf(DEBUG_ERROR, "Failed to lock connection"); return ; } mpd_startPlaylistSearch(mi->connection, exact); /* Set search type */ mi->search_type = (exact)? MPD_SEARCH_TYPE_PLAYLIST_FIND:MPD_SEARCH_TYPE_PLAYLIST_SEARCH; /* unlock, let the error handler handle any possible error. */ mpd_unlock_conn(mi); return; }
int mpd_player_seek(MpdObj * mi, int sec) { int cur_song = mpd_player_get_current_song_pos(mi); if (cur_song < 0) { debug_printf(DEBUG_ERROR, "mpd_player_get_current_song_pos returned error\n"); return cur_song; } if (!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING, "not connected\n"); return MPD_NOT_CONNECTED; } if (mpd_lock_conn(mi)) { debug_printf(DEBUG_WARNING, "lock failed\n"); return MPD_LOCK_FAILED; } debug_printf(DEBUG_INFO, "seeking in song %i to %i sec\n", cur_song, sec); mpd_sendSeekCommand(mi->connection, cur_song, sec); mpd_finishCommand(mi->connection); mpd_unlock_conn(mi); if (mpd_status_update(mi)) { return MPD_STATUS_FAILED; } return MPD_OK; }
int mpd_playlist_load(MpdObj *mi, const char *path) { int retv = MPD_OK; if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"mpd_playlist_load: not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendLoadCommand(mi->connection,path); mpd_finishCommand(mi->connection); if(mi->connection->errorCode == MPD_ACK_ERROR_NO_EXIST) { debug_printf(DEBUG_WARNING, "mpd_playlist_load: failed to load playlist\n"); mpd_clearError(mi->connection); retv = MPD_PLAYLIST_LOAD_FAILED; } if(mpd_unlock_conn(mi)) { debug_printf(DEBUG_ERROR, "Failed to unlock connection"); return MPD_LOCK_FAILED; } return retv; }
/** * @param mi A #MpdObj * @param field A #mpd_TagItems * * Adds a constraint to the search */ void mpd_database_search_add_constraint(MpdObj *mi, mpd_TagItems field, const char *value) { if(mi == NULL || value == NULL || value[0] == '\0') { debug_printf(DEBUG_ERROR,"Failed to parse arguments"); return; } if(mi->search_type == MPD_SEARCH_TYPE_NONE) { debug_printf(DEBUG_ERROR, "No search to constraint"); return; } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_ERROR, "Not Connected\n"); return ; } if(!mpd_server_check_version(mi, 0,12,0)) { debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.0 or higher"); return ; } /* lock, so we can work on mi->connection */ if(mpd_lock_conn(mi) != MPD_OK) { debug_printf(DEBUG_ERROR, "Failed to lock connection"); return ; } mpd_addConstraintSearch(mi->connection, field, value); /* unlock, let the error handler handle any possible error. */ mpd_unlock_conn(mi); return; }
void mpd_database_search_stats_start(MpdObj *mi) { /* * Check argument */ if(mi == NULL) { debug_printf(DEBUG_ERROR, "Argument error"); return ; } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_ERROR, "Not Connected\n"); return ; } if(!mpd_server_check_version(mi, 0,12,0)) { debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.0 or higher"); return ; } /* lock, so we can work on mi->connection */ if(mpd_lock_conn(mi) != MPD_OK) { debug_printf(DEBUG_ERROR, "Failed to lock connection"); return ; } mpd_startStatsSearch(mi->connection); /* Set search type */ mi->search_type = MPD_SEARCH_TYPE_STATS; /* unlock, let the error handler handle any possible error. */ mpd_unlock_conn(mi); return; }
void mpd_database_search_field_start(MpdObj *mi, mpd_TagItems field) { /* * Check argument */ if(mi == NULL || field >= MPD_TAG_NUM_OF_ITEM_TYPES || field < 0) { debug_printf(DEBUG_ERROR, "Argument error"); return ; } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_ERROR, "Not Connected\n"); return ; } if(!mpd_server_check_version(mi, 0,12,0)) { debug_printf(DEBUG_ERROR, "Advanced field list requires mpd 0.12.0 or higher"); return ; } /* lock, so we can work on mi->connection */ if(mpd_lock_conn(mi) != MPD_OK) { debug_printf(DEBUG_ERROR, "Failed to lock connection"); return ; } mpd_startFieldSearch(mi->connection, field); /* Set search type */ mi->search_type = MPD_SEARCH_TYPE_LIST; mi->search_field = field; /* unlock, let the error handler handle any possible error. */ mpd_unlock_conn(mi); return; }
MpdData * mpd_database_get_artists(MpdObj *mi) { char *string = NULL; MpdData *data = 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; } mpd_sendListCommand(mi->connection,MPD_TABLE_ARTIST,NULL); while (( string = mpd_getNextArtist(mi->connection)) != NULL) { data = mpd_new_data_struct_append(data); data->type = MPD_DATA_TYPE_TAG; data->tag_type = MPD_TAG_ITEM_ARTIST; data->tag = string; } mpd_finishCommand(mi->connection); /* unlock */ mpd_unlock_conn(mi); if(data == NULL) { return NULL; } data = mpd_misc_sort_tag_list(data); return mpd_data_get_first(data); }
int mpd_status_set_volume(MpdObj *mi,int volume) { if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return MPD_NOT_CONNECTED; } /* making sure volume is between 0 and 100 */ volume = (volume < 0)? 0:(volume>100)? 100:volume; if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } /* send the command */ mpd_sendSetvolCommand(mi->connection , volume); mpd_finishCommand(mi->connection); /* check for errors */ mpd_unlock_conn(mi); /* update status, because we changed it */ mpd_status_queue_update(mi); /* return current volume */ return mpd_status_get_volume(mi); }
MpdData * mpd_server_get_output_devices(MpdObj *mi) { mpd_OutputEntity *output = NULL; MpdData *data = NULL; if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return NULL; } /* TODO: Check version */ if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return NULL; } mpd_sendOutputsCommand(mi->connection); while (( output = mpd_getNextOutput(mi->connection)) != NULL) { data = mpd_new_data_struct_append(data); data->type = MPD_DATA_TYPE_OUTPUT_DEV; data->output_dev = output; } mpd_finishCommand(mi->connection); /* unlock */ mpd_unlock_conn(mi); if(data == NULL) { return NULL; } return mpd_data_get_first(data); }
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); }
/** * @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; }
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); }
int mpd_server_get_allowed_commands(MpdObj *mi) { char *temp = NULL; int num_commands = 0; if(!mi){ debug_printf(DEBUG_ERROR, "mi != NULL failed\n"); return MPD_ARGS_ERROR; } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING, "Not Connected"); return MPD_NOT_CONNECTED; } if(!mpd_server_check_version(mi,0,12,0)){ debug_printf(DEBUG_INFO, "Not supported by mpd"); return MPD_SERVER_NOT_SUPPORTED; } mpd_server_free_commands(mi); if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR, "lock failed"); return MPD_LOCK_FAILED; } mpd_sendCommandsCommand(mi->connection); while((temp = mpd_getNextCommand(mi->connection))) { num_commands++; mi->commands = realloc(mi->commands, (num_commands+1)*sizeof(MpdCommand)); mi->commands[num_commands-1].command_name = temp; mi->commands[num_commands-1].enabled = TRUE; mi->commands[num_commands].command_name = NULL; mi->commands[num_commands].enabled = FALSE; } mpd_finishCommand(mi->connection); mpd_sendNotCommandsCommand(mi->connection); while((temp = mpd_getNextCommand(mi->connection))) { num_commands++; mi->commands = realloc(mi->commands, (num_commands+1)*sizeof(MpdCommand)); mi->commands[num_commands-1].command_name = temp; mi->commands[num_commands-1].enabled = FALSE; mi->commands[num_commands].command_name = NULL; mi->commands[num_commands].enabled = FALSE; } mpd_finishCommand(mi->connection); if(mpd_unlock_conn(mi)) { return MPD_LOCK_FAILED; } return MPD_OK; }
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); }
int mpd_stats_update_real(MpdObj *mi, ChangedStatusType* what_changed) { ChangedStatusType what_changed_here = 0; if ( what_changed == NULL ) { /* we need to save the current state, because we're called standalone */ memcpy(&(mi->OldState), &(mi->CurrentState), sizeof(MpdServerState)); } if(!mpd_check_connected(mi)) { debug_printf(DEBUG_INFO,"not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } if(mi->stats != NULL) { mpd_freeStats(mi->stats); } mpd_sendStatsCommand(mi->connection); mi->stats = mpd_getStats(mi->connection); if(mi->stats == NULL) { debug_printf(DEBUG_ERROR,"Failed to grab stats from mpd\n"); } else if(mi->stats->dbUpdateTime != mi->OldState.dbUpdateTime) { debug_printf(DEBUG_INFO, "database updated\n"); what_changed_here |= MPD_CST_DATABASE; mi->CurrentState.dbUpdateTime = mi->stats->dbUpdateTime; } if (what_changed) { (*what_changed) |= what_changed_here; } else { if((mi->the_status_changed_callback != NULL) & what_changed_here) { mi->the_status_changed_callback(mi, what_changed_here, mi->the_status_changed_signal_userdata); } } if(mpd_unlock_conn(mi)) { debug_printf(DEBUG_ERROR, "unlock failed"); return MPD_LOCK_FAILED; } return MPD_OK; }
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; }
/******************************************************************************* * 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 mpd_player_set_random(MpdObj * mi, int random) { if (!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING, "not connected\n"); return MPD_NOT_CONNECTED; } if (mpd_lock_conn(mi)) { debug_printf(DEBUG_WARNING, "lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendRandomCommand(mi->connection, random); mpd_finishCommand(mi->connection); mpd_unlock_conn(mi); mpd_status_queue_update(mi); return MPD_OK; }
int mpd_playlist_swap_id (MpdObj *mi, int old_id, int new_id) { if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendSwapIdCommand(mi->connection,old_id, new_id); mpd_finishCommand(mi->connection); /* unlock */ mpd_unlock_conn(mi); return MPD_OK; }
int mpd_status_set_crossfade(MpdObj *mi,int crossfade_time) { if(!mpd_check_connected(mi)) { debug_printf(DEBUG_WARNING,"not connected\n"); return MPD_NOT_CONNECTED; } if(mpd_lock_conn(mi)) { debug_printf(DEBUG_ERROR,"lock failed\n"); return MPD_LOCK_FAILED; } mpd_sendCrossfadeCommand(mi->connection, crossfade_time); mpd_finishCommand(mi->connection); mpd_unlock_conn(mi); mpd_status_queue_update(mi); return MPD_OK; }