58a5d30826
When MPD is not playing, it may still remember which is the "current" song. When you switch to "random" mode, MPD will always start playing exactly this song. This defies the goal of "random" mode a little. Clear the "current" song when MPD is not playing during the "random" mode switch.
370 lines
8.8 KiB
C
370 lines
8.8 KiB
C
/* the Music Player Daemon (MPD)
|
|
* Copyright (C) 2003-2007 by Warren Dukes (warren.dukes@gmail.com)
|
|
* This project's homepage is: http://www.musicpd.org
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "playlist_internal.h"
|
|
#include "playlist_save.h"
|
|
#include "player_control.h"
|
|
#include "command.h"
|
|
#include "tag.h"
|
|
#include "song.h"
|
|
#include "conf.h"
|
|
#include "stored_playlist.h"
|
|
#include "idle.h"
|
|
|
|
#include <glib.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#undef G_LOG_DOMAIN
|
|
#define G_LOG_DOMAIN "playlist"
|
|
|
|
void playlistVersionChange(struct playlist *playlist)
|
|
{
|
|
queue_modify_all(&playlist->queue);
|
|
idle_add(IDLE_PLAYLIST);
|
|
}
|
|
|
|
void
|
|
playlist_tag_changed(struct playlist *playlist)
|
|
{
|
|
if (!playlist->playing)
|
|
return;
|
|
|
|
assert(playlist->current >= 0);
|
|
|
|
queue_modify(&playlist->queue, playlist->current);
|
|
idle_add(IDLE_PLAYLIST);
|
|
}
|
|
|
|
void
|
|
playlist_init(struct playlist *playlist)
|
|
{
|
|
queue_init(&playlist->queue,
|
|
config_get_positive(CONF_MAX_PLAYLIST_LENGTH,
|
|
DEFAULT_PLAYLIST_MAX_LENGTH));
|
|
|
|
playlist->queued = -1;
|
|
playlist->current = -1;
|
|
}
|
|
|
|
void
|
|
playlist_finish(struct playlist *playlist)
|
|
{
|
|
queue_finish(&playlist->queue);
|
|
}
|
|
|
|
/**
|
|
* Queue a song, addressed by its order number.
|
|
*/
|
|
static void
|
|
playlist_queue_song_order(struct playlist *playlist, unsigned order)
|
|
{
|
|
struct song *song;
|
|
char *uri;
|
|
|
|
assert(queue_valid_order(&playlist->queue, order));
|
|
|
|
playlist->queued = order;
|
|
|
|
song = queue_get_order(&playlist->queue, order);
|
|
uri = song_get_uri(song);
|
|
g_debug("queue song %i:\"%s\"", playlist->queued, uri);
|
|
g_free(uri);
|
|
|
|
queueSong(song);
|
|
}
|
|
|
|
/**
|
|
* Check if the player thread has already started playing the "queued"
|
|
* song.
|
|
*/
|
|
static void syncPlaylistWithQueue(struct playlist *playlist)
|
|
{
|
|
if (pc.next_song == NULL && playlist->queued != -1) {
|
|
/* queued song has started: copy queued to current,
|
|
and notify the clients */
|
|
|
|
playlist->current = playlist->queued;
|
|
playlist->queued = -1;
|
|
|
|
idle_add(IDLE_PLAYER);
|
|
}
|
|
}
|
|
|
|
const struct song *
|
|
playlist_get_queued_song(struct playlist *playlist)
|
|
{
|
|
if (!playlist->playing || playlist->queued < 0)
|
|
return NULL;
|
|
|
|
return queue_get_order(&playlist->queue, playlist->queued);
|
|
}
|
|
|
|
void
|
|
playlist_update_queued_song(struct playlist *playlist, const struct song *prev)
|
|
{
|
|
int next_order;
|
|
const struct song *next_song;
|
|
|
|
if (!playlist->playing)
|
|
return;
|
|
|
|
assert(!queue_is_empty(&playlist->queue));
|
|
assert((playlist->queued < 0) == (prev == NULL));
|
|
|
|
next_order = playlist->current >= 0
|
|
? queue_next_order(&playlist->queue, playlist->current)
|
|
: 0;
|
|
|
|
if (next_order == 0 && playlist->queue.random) {
|
|
/* shuffle the song order again, so we get a different
|
|
order each time the playlist is played
|
|
completely */
|
|
unsigned current_position =
|
|
queue_order_to_position(&playlist->queue,
|
|
playlist->current);
|
|
|
|
queue_shuffle_order(&playlist->queue);
|
|
|
|
/* make sure that the playlist->current still points to
|
|
the current song, after the song order has been
|
|
shuffled */
|
|
playlist->current =
|
|
queue_position_to_order(&playlist->queue,
|
|
current_position);
|
|
}
|
|
|
|
if (next_order >= 0)
|
|
next_song = queue_get_order(&playlist->queue, next_order);
|
|
else
|
|
next_song = NULL;
|
|
|
|
if (prev != NULL && next_song != prev) {
|
|
/* clear the currently queued song */
|
|
pc_cancel();
|
|
playlist->queued = -1;
|
|
}
|
|
|
|
if (next_order >= 0) {
|
|
if (next_song != prev)
|
|
playlist_queue_song_order(playlist, next_order);
|
|
else
|
|
playlist->queued = next_order;
|
|
}
|
|
}
|
|
|
|
void
|
|
playPlaylistOrderNumber(struct playlist *playlist, int orderNum)
|
|
{
|
|
struct song *song;
|
|
char *uri;
|
|
|
|
playlist->playing = true;
|
|
playlist->queued = -1;
|
|
|
|
song = queue_get_order(&playlist->queue, orderNum);
|
|
|
|
uri = song_get_uri(song);
|
|
g_debug("play %i:\"%s\"", orderNum, uri);
|
|
g_free(uri);
|
|
|
|
playerPlay(song);
|
|
playlist->current = orderNum;
|
|
}
|
|
|
|
static void
|
|
playPlaylistIfPlayerStopped(struct playlist *playlist);
|
|
|
|
/**
|
|
* This is the "PLAYLIST" event handler. It is invoked by the player
|
|
* thread whenever it requests a new queued song, or when it exits.
|
|
*/
|
|
void syncPlayerAndPlaylist(struct playlist *playlist)
|
|
{
|
|
if (!playlist->playing)
|
|
/* this event has reached us out of sync: we aren't
|
|
playing anymore; ignore the event */
|
|
return;
|
|
|
|
if (getPlayerState() == PLAYER_STATE_STOP)
|
|
/* the player thread has stopped: check if playback
|
|
should be restarted with the next song. That can
|
|
happen if the playlist isn't filling the queue fast
|
|
enough */
|
|
playPlaylistIfPlayerStopped(playlist);
|
|
else {
|
|
/* check if the player thread has already started
|
|
playing the queued song */
|
|
syncPlaylistWithQueue(playlist);
|
|
|
|
/* make sure the queued song is always set (if
|
|
possible) */
|
|
if (pc.next_song == NULL)
|
|
playlist_update_queued_song(playlist, NULL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The player has stopped for some reason. Check the error, and
|
|
* decide whether to re-start playback
|
|
*/
|
|
static void
|
|
playPlaylistIfPlayerStopped(struct playlist *playlist)
|
|
{
|
|
enum player_error error;
|
|
|
|
assert(playlist->playing);
|
|
assert(getPlayerState() == PLAYER_STATE_STOP);
|
|
|
|
error = getPlayerError();
|
|
if (error == PLAYER_ERROR_NOERROR)
|
|
playlist->error_count = 0;
|
|
else
|
|
++playlist->error_count;
|
|
|
|
if ((playlist->stop_on_error && error != PLAYER_ERROR_NOERROR) ||
|
|
error == PLAYER_ERROR_AUDIO || error == PLAYER_ERROR_SYSTEM ||
|
|
playlist->error_count >= queue_length(&playlist->queue))
|
|
/* too many errors, or critical error: stop
|
|
playback */
|
|
stopPlaylist(playlist);
|
|
else
|
|
/* continue playback at the next song */
|
|
nextSongInPlaylist(playlist);
|
|
}
|
|
|
|
bool
|
|
getPlaylistRepeatStatus(const struct playlist *playlist)
|
|
{
|
|
return playlist->queue.repeat;
|
|
}
|
|
|
|
bool
|
|
getPlaylistRandomStatus(const struct playlist *playlist)
|
|
{
|
|
return playlist->queue.random;
|
|
}
|
|
|
|
void setPlaylistRepeatStatus(struct playlist *playlist, bool status)
|
|
{
|
|
if (status == playlist->queue.repeat)
|
|
return;
|
|
|
|
playlist->queue.repeat = status;
|
|
|
|
/* if the last song is currently being played, the "next song"
|
|
might change when repeat mode is toggled */
|
|
playlist_update_queued_song(playlist,
|
|
playlist_get_queued_song(playlist));
|
|
|
|
idle_add(IDLE_OPTIONS);
|
|
}
|
|
|
|
static void orderPlaylist(struct playlist *playlist)
|
|
{
|
|
if (playlist->current >= 0)
|
|
/* update playlist.current, order==position now */
|
|
playlist->current = queue_order_to_position(&playlist->queue,
|
|
playlist->current);
|
|
|
|
queue_restore_order(&playlist->queue);
|
|
}
|
|
|
|
void setPlaylistRandomStatus(struct playlist *playlist, bool status)
|
|
{
|
|
const struct song *queued;
|
|
|
|
if (status == playlist->queue.random)
|
|
return;
|
|
|
|
queued = playlist_get_queued_song(playlist);
|
|
|
|
playlist->queue.random = status;
|
|
|
|
if (playlist->queue.random) {
|
|
/* shuffle the queue order, but preserve
|
|
playlist->current */
|
|
|
|
int current_position =
|
|
playlist->playing && playlist->current >= 0
|
|
? (int)queue_order_to_position(&playlist->queue,
|
|
playlist->current)
|
|
: -1;
|
|
|
|
queue_shuffle_order(&playlist->queue);
|
|
|
|
if (current_position >= 0) {
|
|
/* make sure the current song is the first in
|
|
the order list, so the whole rest of the
|
|
playlist is played after that */
|
|
unsigned current_order =
|
|
queue_position_to_order(&playlist->queue,
|
|
current_position);
|
|
queue_swap_order(&playlist->queue, 0, current_order);
|
|
playlist->current = 0;
|
|
} else
|
|
playlist->current = -1;
|
|
} else
|
|
orderPlaylist(playlist);
|
|
|
|
playlist_update_queued_song(playlist, queued);
|
|
|
|
idle_add(IDLE_OPTIONS);
|
|
}
|
|
|
|
int getPlaylistCurrentSong(const struct playlist *playlist)
|
|
{
|
|
if (playlist->current >= 0)
|
|
return queue_order_to_position(&playlist->queue,
|
|
playlist->current);
|
|
|
|
return -1;
|
|
}
|
|
|
|
int getPlaylistNextSong(const struct playlist *playlist)
|
|
{
|
|
if (playlist->current >= 0)
|
|
{
|
|
if (playlist->current + 1 < (int)queue_length(&playlist->queue))
|
|
return queue_order_to_position(&playlist->queue,
|
|
playlist->current + 1);
|
|
else if (playlist->queue.repeat == 1)
|
|
return queue_order_to_position(&playlist->queue, 0);
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
unsigned long
|
|
getPlaylistVersion(const struct playlist *playlist)
|
|
{
|
|
return playlist->queue.version;
|
|
}
|
|
|
|
int
|
|
getPlaylistLength(const struct playlist *playlist)
|
|
{
|
|
return queue_length(&playlist->queue);
|
|
}
|
|
|
|
unsigned
|
|
getPlaylistSongId(const struct playlist *playlist, unsigned song)
|
|
{
|
|
return queue_position_to_id(&playlist->queue, song);
|
|
}
|