/* This function update the internal status tracking * the MPD status. At then end, if the status has changed, a signal is emmited. */ void Player::updateStatus() { struct mpd_status *statusMpd; EMSPlayerStatus statusEMS; /* Get the status structure from MPD */ mpd_send_status(conn); statusMpd = mpd_recv_status(conn); if (statusMpd == NULL) { qCritical() << "Error while trying to get MPD status"; qCritical() << "Reconnecting..."; connectToMpd(); /* Reconnect */ return; } if (mpd_status_get_error(statusMpd) != NULL) { qCritical() << "MPD error: " << QString::fromUtf8(mpd_status_get_error(statusMpd)); } if (!mpd_response_finish(conn)) { qCritical() << "Error while trying to get MPD status" ; qCritical() << "Reconnecting..."; connectToMpd(); return; } /* Fill the internal state from the answer */ switch (mpd_status_get_state(statusMpd)) { case MPD_STATE_PAUSE: statusEMS.state = STATUS_PAUSE; break; case MPD_STATE_PLAY: statusEMS.state = STATUS_PLAY; break; case MPD_STATE_STOP: statusEMS.state = STATUS_STOP; break; default: statusEMS.state = STATUS_UNKNOWN; break; } statusEMS.repeat = mpd_status_get_repeat(statusMpd); statusEMS.random = mpd_status_get_random(statusMpd); if (statusEMS.state == STATUS_PLAY || statusEMS.state == STATUS_PAUSE) { if (mpd_status_get_queue_length(statusMpd) != (unsigned int)playlist.tracks.size()) { qCritical() << "Error: the playlist does not have the same size as the one used by MPD!"; /* We should not do this... */ removeAllTracks(); } statusEMS.posInPlaylist = mpd_status_get_song_pos(statusMpd); statusEMS.progress = mpd_status_get_elapsed_time(statusMpd); } mpd_status_free(statusMpd); if (statusEMS.posInPlaylist != status.posInPlaylist || statusEMS.progress != status.progress || statusEMS.random != status.random || statusEMS.repeat != status.repeat || statusEMS.state != status.state ) { mutex.lock(); status = statusEMS; mutex.unlock(); emit statusChanged(statusEMS); } }
void MpdWidget::psMpdHB() { timerMpd->stop(); QString dataSender, dataVol, dataTitle; struct mpd_connection *conn; struct mpd_status * status; struct mpd_song *song; // const struct mpd_audio_format *audio_format; conn = mpd_connection_new(NULL, 0, 30000); if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { timerMpd->start(); return; } if (aktPlay) { aktPlay = false; mpd_send_command(conn, "play", NULL); timerMpd->start(); return; } if (aktStop) { aktStop = false; mpd_send_command(conn, "stop", NULL); timerMpd->start(); return; } mpd_command_list_begin(conn, true); mpd_send_status(conn); mpd_send_current_song(conn); mpd_command_list_end(conn); // Status status = mpd_recv_status(conn); if (status == NULL) { timerMpd->start(); return ; } // Volume dataVol.number(mpd_status_get_volume(status)); if (labelVol->text().compare(dataVol) != 0) labelVol->setText(dataVol); if (mpd_status_get_error(status) != NULL) new QListWidgetItem(QString("status error: %1"). arg(mpd_status_get_error(status))); mpd_status_free(status); // Status mpd_response_next(conn); // Song song = mpd_recv_song(conn); if (song == NULL) { handle_error(conn); timerMpd->start(); return ; } // Title dataTitle = mpd_song_get_uri(song); if (labelTitle->text().compare(dataTitle) != 0) labelTitle->setText(dataTitle); unsigned int i = 0; QString value; while ((value = mpd_song_get_tag(song, MPD_TAG_TITLE, i++)) != NULL) { if (i > 0) dataSender.append(" "); dataSender.append(value); } if (labelSender->text().compare(dataSender) != 0) { labelSender->setText(dataSender); qDebug() << "refresh"; } mpd_song_free(song); // Song mpd_connection_free(conn); timerMpd->start(); }
/* * Returns: 0 - error; 1 - ok */ int mgr_mpd_fetch_status( struct mpd_connection *conn, int dump_status ) { struct mpd_status *status; struct mpd_stats *stats; if (DEBUG > 1) fprintf(stderr, "DEBUG: [mgr-thread] mpd: -status fetching...\n"); if (conn == NULL) { fprintf(stderr, "ERROR: MPD: Unable to retrieve the MPD status: not connected\n"); return 0; } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { fprintf(stderr, "ERROR: MPD: Unable to retrieve MPD status: connection error\n"); return 0; } if (DEBUG > 1) fprintf(stderr, "DEBUG: [mgr-thread] mpd: run status\n"); status = mpd_run_status(conn); if (!status) { fprintf(stderr, "ERROR: MPD: Unable to retrieve MPD status\n"); return 0; } cur_mpd_player_status = mpd_status_get_state(status); if (DEBUG > 1) { fprintf(stderr, "DEBUG: [mgr-thread] mpd: +status received:\n"); } if (DEBUG && dump_status) { fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => mode : %s\n", (cur_mpd_player_status == MPD_STATE_PLAY ? "Play" : "Other")); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => random : %d\n", mpd_status_get_random(status)); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => repeat : %d\n", mpd_status_get_random(status)); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => volume : %d\n", mpd_status_get_volume(status)); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => queue ver : %d\n", mpd_status_get_queue_version(status)); fprintf(stderr, "DEBUG: [mgr-thread] mpd status: => queue len : %d\n", mpd_status_get_queue_length(status)); } cur_mpd_random = mpd_status_get_random(status) ? 1 : 0; cur_mpd_volume = mpd_status_get_volume(status); cur_mpd_status_queue_len = mpd_status_get_queue_length(status); if (DEBUG > 1) fprintf(stderr, "DEBUG: [mgr-thread] mpd: release status\n"); if (mpd_status_get_error(status) != NULL) { fprintf(stderr, "WARNING: MPD: Error Received from MPD: %s\n", mpd_status_get_error(status)); // TODO - clear error } mpd_status_free(status); mpd_response_finish(conn); stats = mpd_run_stats(conn); if (stats == NULL) { fprintf(stderr, "ERROR: MPD: Unable to retrieve MPD statistics\n"); return 0; } cur_mpd_stats_number_of_songs = mpd_stats_get_number_of_songs( stats ); if (DEBUG && dump_status) { fprintf(stderr, "DEBUG: [mgr-thread] mpd stats : => # of songs: %d\n", cur_mpd_stats_number_of_songs); } mpd_stats_free( stats ); return 1; }
static int lmpdstatus_index(lua_State *L) { const char *key; const struct mpd_audio_format *audio_format; struct mpd_status **status; status = luaL_checkudata(L, 1, MPD_STATUS_T); key = luaL_checkstring(L, 2); assert(*status != NULL); if (strncmp(key, "volume", 7) == 0) { lua_pushinteger(L, mpd_status_get_volume(*status)); return 1; } else if (strncmp(key, "repeat", 7) == 0) { lua_pushinteger(L, mpd_status_get_repeat(*status)); return 1; } else if (strncmp(key, "random", 7) == 0) { lua_pushinteger(L, mpd_status_get_random(*status)); return 1; } else if (strncmp(key, "single", 7) == 0) { lua_pushinteger(L, mpd_status_get_single(*status)); return 1; } else if (strncmp(key, "consume", 8) == 0) { lua_pushinteger(L, mpd_status_get_consume(*status)); return 1; } else if (strncmp(key, "queue_length", 16) == 0) { lua_pushnumber(L, mpd_status_get_queue_length(*status)); return 1; } else if (strncmp(key, "queue_version", 17) == 0) { lua_pushnumber(L, mpd_status_get_queue_version(*status)); return 1; } else if (strncmp(key, "state", 6) == 0) { lua_pushinteger(L, mpd_status_get_state(*status)); return 1; } else if (strncmp(key, "crossfade", 10) == 0) { lua_pushinteger(L, mpd_status_get_crossfade(*status)); return 1; } else if (strncmp(key, "song_pos", 5) == 0) { lua_pushinteger(L, mpd_status_get_song_pos(*status)); return 1; } else if (strncmp(key, "song_id", 7) == 0) { lua_pushinteger(L, mpd_status_get_song_id(*status)); return 1; } else if (strncmp(key, "elapsed_time", 13) == 0) { lua_pushinteger(L, mpd_status_get_elapsed_time(*status)); return 1; } else if (strncmp(key, "total_time", 11) == 0) { lua_pushinteger(L, mpd_status_get_total_time(*status)); return 1; } else if (strncmp(key, "kbit_rate", 10) == 0) { lua_pushinteger(L, mpd_status_get_kbit_rate(*status)); return 1; } else if (strncmp(key, "audio_format", 13) == 0) { audio_format = mpd_status_get_audio_format(*status); lua_newtable(L); lua_pushinteger(L, audio_format->sample_rate); lua_setfield(L, -2, "sample_rate"); lua_pushinteger(L, audio_format->bits); lua_setfield(L, -2, "bits"); lua_pushinteger(L, audio_format->channels); lua_setfield(L, -2, "channels"); return 1; } else if (strncmp(key, "update_id", 11) == 0) { lua_pushinteger(L, mpd_status_get_update_id(*status)); return 1; } else if (strncmp(key, "error", 6) == 0) { lua_pushstring(L, mpd_status_get_error(*status)); return 1; } else return luaL_error(L, "Invalid key `%s'", key); }
int main(int argc, char ** argv) { struct mpd_connection *conn; conn = mpd_connection_new(NULL, 0, 30000); if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) return handle_error(conn); { int i; for(i=0;i<3;i++) { printf("version[%i]: %i\n",i, mpd_connection_get_server_version(conn)[i]); } } if(argc==1) { struct mpd_status * status; struct mpd_song *song; const struct mpd_audio_format *audio_format; 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 (status == NULL) return handle_error(conn); printf("volume: %i\n", mpd_status_get_volume(status)); printf("repeat: %i\n", mpd_status_get_repeat(status)); printf("queue version: %u\n", mpd_status_get_queue_version(status)); printf("queue length: %i\n", mpd_status_get_queue_length(status)); if (mpd_status_get_error(status) != NULL) printf("error: %s\n", mpd_status_get_error(status)); if (mpd_status_get_state(status) == MPD_STATE_PLAY || mpd_status_get_state(status) == MPD_STATE_PAUSE) { printf("song: %i\n", mpd_status_get_song_pos(status)); printf("elaspedTime: %i\n",mpd_status_get_elapsed_time(status)); printf("elasped_ms: %u\n", mpd_status_get_elapsed_ms(status)); printf("totalTime: %i\n", mpd_status_get_total_time(status)); printf("bitRate: %i\n", mpd_status_get_kbit_rate(status)); } audio_format = mpd_status_get_audio_format(status); if (audio_format != NULL) { printf("sampleRate: %i\n", audio_format->sample_rate); printf("bits: %i\n", audio_format->bits); printf("channels: %i\n", audio_format->channels); } mpd_status_free(status); if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) return handle_error(conn); mpd_response_next(conn); while ((song = mpd_recv_song(conn)) != NULL) { printf("uri: %s\n", mpd_song_get_uri(song)); print_tag(song, MPD_TAG_ARTIST, "artist"); print_tag(song, MPD_TAG_ALBUM, "album"); print_tag(song, MPD_TAG_TITLE, "title"); print_tag(song, MPD_TAG_TRACK, "track"); print_tag(song, MPD_TAG_NAME, "name"); print_tag(song, MPD_TAG_DATE, "date"); if (mpd_song_get_duration(song) > 0) { printf("time: %u\n", mpd_song_get_duration(song)); } printf("pos: %u\n", mpd_song_get_pos(song)); mpd_song_free(song); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if(argc==3 && strcmp(argv[1],"lsinfo")==0) { struct mpd_entity * entity; if (!mpd_send_list_meta(conn, argv[2])) return handle_error(conn); while ((entity = mpd_recv_entity(conn)) != NULL) { const struct mpd_song *song; const struct mpd_directory *dir; const struct mpd_playlist *pl; switch (mpd_entity_get_type(entity)) { case MPD_ENTITY_TYPE_UNKNOWN: break; case MPD_ENTITY_TYPE_SONG: song = mpd_entity_get_song(entity); printf("uri: %s\n", mpd_song_get_uri(song)); print_tag(song, MPD_TAG_ARTIST, "artist"); print_tag(song, MPD_TAG_ALBUM, "album"); print_tag(song, MPD_TAG_TITLE, "title"); print_tag(song, MPD_TAG_TRACK, "track"); break; case MPD_ENTITY_TYPE_DIRECTORY: dir = mpd_entity_get_directory(entity); printf("directory: %s\n", mpd_directory_get_path(dir)); break; case MPD_ENTITY_TYPE_PLAYLIST: pl = mpd_entity_get_playlist(entity); printf("playlist: %s\n", mpd_playlist_get_path(pl)); break; } mpd_entity_free(entity); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if(argc==2 && strcmp(argv[1],"artists")==0) { struct mpd_pair *pair; if (!mpd_search_db_tags(conn, MPD_TAG_ARTIST) || !mpd_search_commit(conn)) return handle_error(conn); while ((pair = mpd_recv_pair_tag(conn, MPD_TAG_ARTIST)) != NULL) { printf("%s\n", pair->value); mpd_return_pair(conn, pair); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if (argc == 2 && strcmp(argv[1], "playlists") == 0) { if (!mpd_send_list_playlists(conn)) return handle_error(conn); struct mpd_playlist *playlist; while ((playlist = mpd_recv_playlist(conn)) != NULL) { printf("%s\n", mpd_playlist_get_path(playlist)); mpd_playlist_free(playlist); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if (argc == 2 && strcmp(argv[1], "idle") == 0) { enum mpd_idle idle = mpd_run_idle(conn); if (idle == 0 && mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) return handle_error(conn); for (unsigned j = 0;; ++j) { enum mpd_idle i = 1 << j; const char *name = mpd_idle_name(i); if (name == NULL) break; if (idle & i) printf("%s\n", name); } } else if (argc == 3 && strcmp(argv[1], "subscribe") == 0) { /* subscribe to a channel and print all messages */ if (!mpd_run_subscribe(conn, argv[2])) return handle_error(conn); while (mpd_run_idle_mask(conn, MPD_IDLE_MESSAGE) != 0) { if (!mpd_send_read_messages(conn)) return handle_error(conn); struct mpd_message *msg; while ((msg = mpd_recv_message(conn)) != NULL) { printf("%s\n", mpd_message_get_text(msg)); mpd_message_free(msg); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } return handle_error(conn); } else if (argc == 2 && strcmp(argv[1], "channels") == 0) { /* print a list of channels */ if (!mpd_send_channels(conn)) return handle_error(conn); struct mpd_pair *pair; while ((pair = mpd_recv_channel_pair(conn)) != NULL) { printf("%s\n", pair->value); mpd_return_pair(conn, pair); } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS || !mpd_response_finish(conn)) return handle_error(conn); } else if (argc == 4 && strcmp(argv[1], "message") == 0) { /* send a message to a channel */ if (!mpd_run_send_message(conn, argv[2], argv[3])) return handle_error(conn); } mpd_connection_free(conn); return 0; }
void mpd_query_status(struct mpd_connection *conn) { struct mpd_status *status; struct mpd_song *song; const struct mpd_audio_format *audio; if (!conn) return; if (!mpd_command_list_begin(conn, true) || !mpd_send_status(conn) || !mpd_send_current_song(conn) || !mpd_command_list_end(conn)) { mpd_printerror("queue_commands"); return; } status = mpd_recv_status(conn); if (status == NULL) { mpd_printerror("recv_status"); return; } if (currentSong != NULL) { mpd_song_free(currentSong); currentSong = NULL; } if (!mpd_response_next(conn)) { mpd_printerror("response_next"); return; } song = mpd_recv_song(conn); if (song != NULL) { currentSong = mpd_song_dup(song); mpd_song_free(song); l_elapsedTimeSec = mpd_status_get_elapsed_time(status); l_totalTimeSec = mpd_status_get_total_time(status); l_bitRate = mpd_status_get_kbit_rate(status); } else { l_elapsedTimeSec = 0; l_totalTimeSec = 0; l_bitRate = 0; } l_state = mpd_status_get_state(status); l_repeatEnabled = mpd_status_get_repeat(status); l_randomEnabled = mpd_status_get_random(status); l_singleEnabled = mpd_status_get_single(status); l_consumeEnabled = mpd_status_get_consume(status); l_volume = mpd_status_get_volume(status); l_currentSongPos = mpd_status_get_song_pos(status) + 1; l_playlistLength = mpd_status_get_queue_length(status); audio = mpd_status_get_audio_format(status); if (audio) { l_sampleRate = audio->sample_rate; l_channels = audio->channels; } else { l_sampleRate = 0; l_channels = 0; } if (mpd_status_get_error(status) != NULL) error("[MPD] query status : %s", charset_from_utf8(mpd_status_get_error(status))); mpd_status_free(status); if (!mpd_response_finish(conn)) { mpd_printerror("response_finish"); return; } }
void print_status(struct mpd_connection *conn) { if (!mpd_command_list_begin(conn, true) || !mpd_send_status(conn) || !mpd_send_current_song(conn) || !mpd_command_list_end(conn)) printErrorAndExit(conn); struct mpd_status *status = mpd_recv_status(conn); if (status == NULL) printErrorAndExit(conn); if (mpd_status_get_state(status) == MPD_STATE_PLAY || mpd_status_get_state(status) == MPD_STATE_PAUSE) { if (!mpd_response_next(conn)) printErrorAndExit(conn); struct mpd_song *song = mpd_recv_song(conn); if (song != NULL) { pretty_print_song(song); printf("\n"); mpd_song_free(song); } if (mpd_status_get_state(status) == MPD_STATE_PLAY) printf("[playing]"); else printf("[paused] "); printf(" #%i/%u %3i:%02i/%i:%02i (%u%%)\n", mpd_status_get_song_pos(status) + 1, mpd_status_get_queue_length(status), mpd_status_get_elapsed_time(status) / 60, mpd_status_get_elapsed_time(status) % 60, mpd_status_get_total_time(status) / 60, mpd_status_get_total_time(status) % 60, elapsed_percent(status)); } if (mpd_status_get_update_id(status) > 0) printf("Updating DB (#%u) ...\n", mpd_status_get_update_id(status)); if (mpd_status_get_volume(status) >= 0) printf("volume:%3i%c ", mpd_status_get_volume(status), '%'); else { printf("volume: n/a "); } printf("repeat: "); if (mpd_status_get_repeat(status)) printf("on "); else printf("off "); printf("random: "); if (mpd_status_get_random(status)) printf("on "); else printf("off "); printf("single: "); if (mpd_status_get_single(status)) printf("on "); else printf("off "); printf("consume: "); if (mpd_status_get_consume(status)) printf("on \n"); else printf("off\n"); if (mpd_status_get_error(status) != NULL) printf("ERROR: %s\n", charset_from_utf8(mpd_status_get_error(status))); mpd_status_free(status); if (!mpd_response_finish(conn)) printErrorAndExit(conn); }