/* the Music Player Daemon (MPD) * (c)2003-2006 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.h" #include "player.h" #include "command.h" #include "ls.h" #include "tag.h" #include "conf.h" #include "directory.h" #include "log.h" #include "path.h" #include "utils.h" #include "sig_handlers.h" #include <string.h> #include <stdlib.h> #include <sys/stat.h> #include <sys/param.h> #include <errno.h> #include <unistd.h> #include <time.h> #define PLAYLIST_COMMENT '#' #define PLAYLIST_STATE_STOP 0 #define PLAYLIST_STATE_PLAY 1 #define PLAYLIST_PREV_UNLESS_ELAPSED 10 #define PLAYLIST_STATE_FILE_STATE "state: " #define PLAYLIST_STATE_FILE_RANDOM "random: " #define PLAYLIST_STATE_FILE_REPEAT "repeat: " #define PLAYLIST_STATE_FILE_CURRENT "current: " #define PLAYLIST_STATE_FILE_TIME "time: " #define PLAYLIST_STATE_FILE_CROSSFADE "crossfade: " #define PLAYLIST_STATE_FILE_PLAYLIST_BEGIN "playlist_begin" #define PLAYLIST_STATE_FILE_PLAYLIST_END "playlist_end" #define PLAYLIST_STATE_FILE_STATE_PLAY "play" #define PLAYLIST_STATE_FILE_STATE_PAUSE "pause" #define PLAYLIST_STATE_FILE_STATE_STOP "stop" #define PLAYLIST_BUFFER_SIZE 2*MAXPATHLEN #define PLAYLIST_HASH_MULT 4 #define DEFAULT_PLAYLIST_MAX_LENGTH (1024*16) #define DEFAULT_PLAYLIST_SAVE_ABSOLUTE_PATHS 0 typedef struct _Playlist { Song **songs; /* holds version a song was modified on */ mpd_uint32 *songMod; int *order; int *positionToId; int *idToPosition; int length; int current; int queued; int repeat; int random; mpd_uint32 version; } Playlist; static Playlist playlist; static int playlist_state = PLAYLIST_STATE_STOP; static int playlist_max_length = DEFAULT_PLAYLIST_MAX_LENGTH; static int playlist_stopOnError; static int playlist_errorCount = 0; static int playlist_queueError; static int playlist_noGoToNext = 0; static int playlist_saveAbsolutePaths = DEFAULT_PLAYLIST_SAVE_ABSOLUTE_PATHS; static void swapOrder(int a, int b); static int playPlaylistOrderNumber(FILE * fp, int orderNum); static void randomizeOrder(int start, int end); char *getStateFile(void) { ConfigParam *param = parseConfigFilePath(CONF_STATE_FILE, 0); if (!param) return NULL; return param->value; } static void incrPlaylistVersion(void) { static unsigned long max = ((mpd_uint32) 1 << 31) - 1; playlist.version++; if (playlist.version >= max) { int i; for (i = 0; i < playlist.length; i++) { playlist.songMod[i] = 0; } playlist.version = 1; } } void playlistVersionChange(void) { int i = 0; for (i = 0; i < playlist.length; i++) { playlist.songMod[i] = playlist.version; } incrPlaylistVersion(); } static void incrPlaylistCurrent(void) { if (playlist.current < 0) return; if (playlist.current >= playlist.length - 1) { if (playlist.repeat) playlist.current = 0; else playlist.current = -1; } else playlist.current++; } void initPlaylist(void) { char *test; int i; ConfigParam *param; playlist.length = 0; playlist.repeat = 0; playlist.version = 1; playlist.random = 0; playlist.queued = -1; playlist.current = -1; param = getConfigParam(CONF_MAX_PLAYLIST_LENGTH); if (param) { playlist_max_length = strtol(param->value, &test, 10); if (*test != '\0') { ERROR("max playlist length \"%s\" is not an integer, " "line %i\n", param->value, param->line); exit(EXIT_FAILURE); } } playlist_saveAbsolutePaths = getBoolConfigParam(CONF_SAVE_ABSOLUTE_PATHS); if (playlist_saveAbsolutePaths == -1) { /* not set */ playlist_saveAbsolutePaths = 0; } else if (playlist_saveAbsolutePaths < 0) { param = getConfigParam(CONF_SAVE_ABSOLUTE_PATHS); ERROR("%s is not \"yes\" or \"no\" on line %i\n", CONF_SAVE_ABSOLUTE_PATHS, param->line); exit(EXIT_FAILURE); } playlist.songs = malloc(sizeof(Song *) * playlist_max_length); playlist.songMod = malloc(sizeof(mpd_uint32) * playlist_max_length); playlist.order = malloc(sizeof(int) * playlist_max_length); playlist.idToPosition = malloc(sizeof(int) * playlist_max_length * PLAYLIST_HASH_MULT); playlist.positionToId = malloc(sizeof(int) * playlist_max_length); memset(playlist.songs, 0, sizeof(char *) * playlist_max_length); srandom(time(NULL)); for (i = 0; i < playlist_max_length * PLAYLIST_HASH_MULT; i++) { playlist.idToPosition[i] = -1; } } static int getNextId(void) { static int cur = -1; do { cur++; if (cur >= playlist_max_length * PLAYLIST_HASH_MULT) { cur = 0; } } while (playlist.idToPosition[cur] != -1); return cur; } void finishPlaylist(void) { int i; for (i = 0; i < playlist.length; i++) { if (playlist.songs[i]->type == SONG_TYPE_URL) { freeJustSong(playlist.songs[i]); } } playlist.length = 0; free(playlist.songs); playlist.songs = NULL; free(playlist.songMod); playlist.songMod = NULL; free(playlist.order); playlist.order = NULL; free(playlist.idToPosition); playlist.idToPosition = NULL; free(playlist.positionToId); playlist.positionToId = NULL; } int clearPlaylist(FILE * fp) { int i; if (stopPlaylist(fp) < 0) return -1; for (i = 0; i < playlist.length; i++) { if (playlist.songs[i]->type == SONG_TYPE_URL) { freeJustSong(playlist.songs[i]); } playlist.idToPosition[playlist.positionToId[i]] = -1; playlist.songs[i] = NULL; } playlist.length = 0; playlist.current = -1; incrPlaylistVersion(); return 0; } int showPlaylist(FILE * fp) { int i; for (i = 0; i < playlist.length; i++) { myfprintf(fp, "%i:%s\n", i, getSongUrl(playlist.songs[i])); } return 0; } void savePlaylistState(void) { char *stateFile = getStateFile(); if (stateFile) { FILE *fp; while (!(fp = fopen(stateFile, "w")) && errno == EINTR) ; if (!fp) { ERROR("problems opening state file \"%s\" for " "writing: %s\n", stateFile, strerror(errno)); return; } myfprintf(fp, "%s", PLAYLIST_STATE_FILE_STATE); switch (playlist_state) { case PLAYLIST_STATE_PLAY: switch (getPlayerState()) { case PLAYER_STATE_PAUSE: myfprintf(fp, "%s\n", PLAYLIST_STATE_FILE_STATE_PAUSE); break; default: myfprintf(fp, "%s\n", PLAYLIST_STATE_FILE_STATE_PLAY); } myfprintf(fp, "%s%i\n", PLAYLIST_STATE_FILE_CURRENT, playlist.order[playlist.current]); myfprintf(fp, "%s%i\n", PLAYLIST_STATE_FILE_TIME, getPlayerElapsedTime()); break; default: myfprintf(fp, "%s\n", PLAYLIST_STATE_FILE_STATE_STOP); break; } myfprintf(fp, "%s%i\n", PLAYLIST_STATE_FILE_RANDOM, playlist.random); myfprintf(fp, "%s%i\n", PLAYLIST_STATE_FILE_REPEAT, playlist.repeat); myfprintf(fp, "%s%i\n", PLAYLIST_STATE_FILE_CROSSFADE, (int)(getPlayerCrossFade())); myfprintf(fp, "%s\n", PLAYLIST_STATE_FILE_PLAYLIST_BEGIN); showPlaylist(fp); myfprintf(fp, "%s\n", PLAYLIST_STATE_FILE_PLAYLIST_END); while (fclose(fp) && errno == EINTR) ; } } void loadPlaylistFromStateFile(FILE * fp, char *buffer, int state, int current, int time) { char *temp; int song; char *stateFile = getStateFile(); if (!myFgets(buffer, PLAYLIST_BUFFER_SIZE, fp)) { ERROR("error parsing state file \"%s\"\n", stateFile); exit(EXIT_FAILURE); } while (strcmp(buffer, PLAYLIST_STATE_FILE_PLAYLIST_END)) { song = atoi(strtok(buffer, ":")); if (!(temp = strtok(NULL, ""))) { ERROR("error parsing state file \"%s\"\n", stateFile); exit(EXIT_FAILURE); } if (addToPlaylist(stderr, temp, 0) == 0 && current == song) { if (state != PLAYER_STATE_STOP) { playPlaylist(stderr, playlist.length - 1, 0); } if (state == PLAYER_STATE_PAUSE) { playerPause(stderr); } if (state != PLAYER_STATE_STOP) { seekSongInPlaylist(stderr, playlist.length - 1, time); } } if (!myFgets(buffer, PLAYLIST_BUFFER_SIZE, fp)) { ERROR("error parsing state file \"%s\"\n", stateFile); exit(EXIT_FAILURE); } } } void readPlaylistState(void) { char *stateFile = getStateFile(); if (stateFile) { FILE *fp; struct stat st; int current = -1; int time = 0; int state = PLAYER_STATE_STOP; char buffer[PLAYLIST_BUFFER_SIZE]; if (stat(stateFile, &st) < 0) { DEBUG("failed to stat state file\n"); return; } if (!S_ISREG(st.st_mode)) { ERROR("state file \"%s\" is not a regular " "file\n", stateFile); exit(EXIT_FAILURE); } fp = fopen(stateFile, "r"); if (!fp) { ERROR("problems opening state file \"%s\" for " "reading: %s\n", stateFile, strerror(errno)); exit(EXIT_FAILURE); } while (myFgets(buffer, PLAYLIST_BUFFER_SIZE, fp)) { if (strncmp(buffer, PLAYLIST_STATE_FILE_STATE, strlen(PLAYLIST_STATE_FILE_STATE)) == 0) { if (strcmp(&(buffer [strlen (PLAYLIST_STATE_FILE_STATE)]), PLAYLIST_STATE_FILE_STATE_PLAY) == 0) { state = PLAYER_STATE_PLAY; } else if (strcmp(&(buffer [strlen (PLAYLIST_STATE_FILE_STATE)]), PLAYLIST_STATE_FILE_STATE_PAUSE) == 0) { state = PLAYER_STATE_PAUSE; } } else if (strncmp(buffer, PLAYLIST_STATE_FILE_TIME, strlen(PLAYLIST_STATE_FILE_TIME)) == 0) { time = atoi(& (buffer [strlen(PLAYLIST_STATE_FILE_TIME)])); } else if (strncmp (buffer, PLAYLIST_STATE_FILE_REPEAT, strlen(PLAYLIST_STATE_FILE_REPEAT)) == 0) { if (strcmp (& (buffer [strlen(PLAYLIST_STATE_FILE_REPEAT)]), "1") == 0) { setPlaylistRepeatStatus(stderr, 1); } else setPlaylistRepeatStatus(stderr, 0); } else if (strncmp (buffer, PLAYLIST_STATE_FILE_CROSSFADE, strlen(PLAYLIST_STATE_FILE_CROSSFADE)) == 0) { setPlayerCrossFade(atoi (& (buffer [strlen (PLAYLIST_STATE_FILE_CROSSFADE)]))); } else if (strncmp (buffer, PLAYLIST_STATE_FILE_RANDOM, strlen(PLAYLIST_STATE_FILE_RANDOM)) == 0) { if (strcmp (& (buffer [strlen(PLAYLIST_STATE_FILE_RANDOM)]), "1") == 0) { setPlaylistRandomStatus(stderr, 1); } else setPlaylistRandomStatus(stderr, 0); } else if (strncmp(buffer, PLAYLIST_STATE_FILE_CURRENT, strlen(PLAYLIST_STATE_FILE_CURRENT)) == 0) { if (strlen(buffer) == strlen(PLAYLIST_STATE_FILE_CURRENT)) { ERROR("error parsing state " "file \"%s\"\n", stateFile); exit(EXIT_FAILURE); } current = atoi(&(buffer [strlen (PLAYLIST_STATE_FILE_CURRENT)])); } else if (strncmp (buffer, PLAYLIST_STATE_FILE_PLAYLIST_BEGIN, strlen(PLAYLIST_STATE_FILE_PLAYLIST_BEGIN) ) == 0) { if (state == PLAYER_STATE_STOP) current = -1; loadPlaylistFromStateFile(fp, buffer, state, current, time); } } fclose(fp); } } void printPlaylistSongInfo(FILE * fp, int song) { printSongInfo(fp, playlist.songs[song]); myfprintf(fp, "Pos: %i\n", song); myfprintf(fp, "Id: %i\n", playlist.positionToId[song]); } int playlistChanges(FILE * fp, mpd_uint32 version) { int i; for (i = 0; i < playlist.length; i++) { if (version > playlist.version || playlist.songMod[i] >= version || playlist.songMod[i] == 0) { printPlaylistSongInfo(fp, i); } } return 0; } int playlistChangesPosId(FILE * fp, mpd_uint32 version) { int i; for (i = 0; i < playlist.length; i++) { if (version > playlist.version || playlist.songMod[i] >= version || playlist.songMod[i] == 0) { myfprintf(fp, "cpos: %i\n", i); myfprintf(fp, "Id: %i\n", playlist.positionToId[i]); } } return 0; } int playlistInfo(FILE * fp, int song) { int i; int begin = 0; int end = playlist.length; if (song >= 0) { begin = song; end = song + 1; } if (song >= playlist.length) { commandError(fp, ACK_ERROR_NO_EXIST, "song doesn't exist: \"%i\"", song); return -1; } for (i = begin; i < end; i++) printPlaylistSongInfo(fp, i); return 0; } # define checkSongId(id) { \ if(id < 0 || id >= PLAYLIST_HASH_MULT*playlist_max_length || \ playlist.idToPosition[id] == -1 ) \ { \ commandError(fp, ACK_ERROR_NO_EXIST, \ "song id doesn't exist: \"%i\"", id); \ return -1; \ } \ } int playlistId(FILE * fp, int id) { int i; int begin = 0; int end = playlist.length; if (id >= 0) { checkSongId(id); begin = playlist.idToPosition[id]; end = begin + 1; } for (i = begin; i < end; i++) printPlaylistSongInfo(fp, i); return 0; } void swapSongs(int song1, int song2) { Song *sTemp; int iTemp; sTemp = playlist.songs[song1]; playlist.songs[song1] = playlist.songs[song2]; playlist.songs[song2] = sTemp; playlist.songMod[song1] = playlist.version; playlist.songMod[song2] = playlist.version; playlist.idToPosition[playlist.positionToId[song1]] = song2; playlist.idToPosition[playlist.positionToId[song2]] = song1; iTemp = playlist.positionToId[song1]; playlist.positionToId[song1] = playlist.positionToId[song2]; playlist.positionToId[song2] = iTemp; } void queueNextSongInPlaylist(void) { if (playlist.current < playlist.length - 1) { playlist.queued = playlist.current + 1; DEBUG("playlist: queue song %i:\"%s\"\n", playlist.queued, getSongUrl(playlist. songs[playlist.order[playlist.queued]])); if (queueSong(playlist.songs[playlist.order[playlist.queued]]) < 0) { playlist.queued = -1; playlist_queueError = 1; } } else if (playlist.length && playlist.repeat) { if (playlist.length > 1 && playlist.random) { randomizeOrder(0, playlist.length - 1); } playlist.queued = 0; DEBUG("playlist: queue song %i:\"%s\"\n", playlist.queued, getSongUrl(playlist. songs[playlist.order[playlist.queued]])); if (queueSong(playlist.songs[playlist.order[playlist.queued]]) < 0) { playlist.queued = -1; playlist_queueError = 1; } } } void syncPlaylistWithQueue(int queue) { if (queue && getPlayerQueueState() == PLAYER_QUEUE_BLANK) { queueNextSongInPlaylist(); } else if (getPlayerQueueState() == PLAYER_QUEUE_DECODE) { if (playlist.queued != -1) setQueueState(PLAYER_QUEUE_PLAY); else setQueueState(PLAYER_QUEUE_STOP); } else if (getPlayerQueueState() == PLAYER_QUEUE_EMPTY) { setQueueState(PLAYER_QUEUE_BLANK); if (playlist.queued >= 0) { DEBUG("playlist: now playing queued song\n"); playlist.current = playlist.queued; } playlist.queued = -1; if (queue) queueNextSongInPlaylist(); } } void lockPlaylistInteraction(void) { if (getPlayerQueueState() == PLAYER_QUEUE_PLAY || getPlayerQueueState() == PLAYER_QUEUE_FULL) { playerQueueLock(); syncPlaylistWithQueue(0); } } static void unlockPlaylistInteraction(void) { playerQueueUnlock(); } void clearPlayerQueue(void) { playlist.queued = -1; switch (getPlayerQueueState()) { case PLAYER_QUEUE_FULL: DEBUG("playlist: dequeue song\n"); setQueueState(PLAYER_QUEUE_BLANK); break; case PLAYER_QUEUE_PLAY: DEBUG("playlist: stop decoding queued song\n"); setQueueState(PLAYER_QUEUE_STOP); break; } } int addToPlaylist(FILE * fp, char *url, int printId) { Song *song; DEBUG("add to playlist: %s\n", url); if ((song = getSongFromDB(url))) { } else if (!(isValidRemoteUtf8Url(url) && (song = newSong(url, SONG_TYPE_URL, NULL)))) { commandError(fp, ACK_ERROR_NO_EXIST, "\"%s\" is not in the music db or is " "not a valid url", url); return -1; } return addSongToPlaylist(fp, song, printId); } int addSongToPlaylist(FILE * fp, Song * song, int printId) { int id; if (playlist.length == playlist_max_length) { commandError(fp, ACK_ERROR_PLAYLIST_MAX, "playlist is at the max size", NULL); return -1; } if (playlist_state == PLAYLIST_STATE_PLAY) { if (playlist.queued >= 0 && playlist.current == playlist.length - 1) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); } } id = getNextId(); playlist.songs[playlist.length] = song; playlist.songMod[playlist.length] = playlist.version; playlist.order[playlist.length] = playlist.length; playlist.positionToId[playlist.length] = id; playlist.idToPosition[playlist.positionToId[playlist.length]] = playlist.length; playlist.length++; if (playlist.random) { int swap; int start; /*if(playlist_state==PLAYLIST_STATE_STOP) start = 0; else */ if (playlist.queued >= 0) start = playlist.queued + 1; else start = playlist.current + 1; if (start < playlist.length) { swap = random() % (playlist.length - start); swap += start; swapOrder(playlist.length - 1, swap); } } incrPlaylistVersion(); if (printId) myfprintf(fp, "Id: %i\n", id); return 0; } int swapSongsInPlaylist(FILE * fp, int song1, int song2) { int queuedSong = -1; int currentSong = -1; if (song1 < 0 || song1 >= playlist.length) { commandError(fp, ACK_ERROR_NO_EXIST, "song doesn't exist: \"%i\"", song1); return -1; } if (song2 < 0 || song2 >= playlist.length) { commandError(fp, ACK_ERROR_NO_EXIST, "song doesn't exist: \"%i\"", song2); return -1; } if (playlist_state == PLAYLIST_STATE_PLAY) { if (playlist.queued >= 0) { queuedSong = playlist.order[playlist.queued]; } currentSong = playlist.order[playlist.current]; if (queuedSong == song1 || queuedSong == song2 || currentSong == song1 || currentSong == song2) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); } } swapSongs(song1, song2); if (playlist.random) { int i; int k; int j = -1; for (i = 0; playlist.order[i] != song1; i++) { if (playlist.order[i] == song2) j = i; } k = i; for (; j == -1; i++) if (playlist.order[i] == song2) j = i; swapOrder(k, j); } else { if (playlist.current == song1) playlist.current = song2; else if (playlist.current == song2) playlist.current = song1; } incrPlaylistVersion(); return 0; } int swapSongsInPlaylistById(FILE * fp, int id1, int id2) { checkSongId(id1); checkSongId(id2); return swapSongsInPlaylist(fp, playlist.idToPosition[id1], playlist.idToPosition[id2]); } #define moveSongFromTo(from, to) { \ playlist.idToPosition[playlist.positionToId[from]] = to; \ playlist.positionToId[to] = playlist.positionToId[from]; \ playlist.songs[to] = playlist.songs[from]; \ playlist.songMod[to] = playlist.version; \ } int deleteFromPlaylist(FILE * fp, int song) { int i; int songOrder; if (song < 0 || song >= playlist.length) { commandError(fp, ACK_ERROR_NO_EXIST, "song doesn't exist: \"%i\"", song); return -1; } if (playlist_state == PLAYLIST_STATE_PLAY) { if (playlist.queued >= 0 && (playlist.order[playlist.queued] == song || playlist.order[playlist.current] == song)) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); } } if (playlist.songs[song]->type == SONG_TYPE_URL) { freeJustSong(playlist.songs[song]); } playlist.idToPosition[playlist.positionToId[song]] = -1; /* delete song from songs array */ for (i = song; i < playlist.length - 1; i++) { moveSongFromTo(i + 1, i); } /* now find it in the order array */ for (i = 0; i < playlist.length - 1; i++) { if (playlist.order[i] == song) break; } songOrder = i; /* delete the entry from the order array */ for (; i < playlist.length - 1; i++) playlist.order[i] = playlist.order[i + 1]; /* readjust values in the order array */ for (i = 0; i < playlist.length - 1; i++) { if (playlist.order[i] > song) playlist.order[i]--; } /* now take care of other misc stuff */ playlist.songs[playlist.length - 1] = NULL; playlist.length--; incrPlaylistVersion(); if (playlist_state != PLAYLIST_STATE_STOP && playlist.current == songOrder) { /*if(playlist.current>=playlist.length) return playerStop(fp); else return playPlaylistOrderNumber(fp,playlist.current); */ playerStop(stderr); playlist_noGoToNext = 1; } if (playlist.current > songOrder) { playlist.current--; } else if (playlist.current >= playlist.length) { incrPlaylistCurrent(); } if (playlist.queued > songOrder) { playlist.queued--; } return 0; } int deleteFromPlaylistById(FILE * fp, int id) { checkSongId(id); return deleteFromPlaylist(fp, playlist.idToPosition[id]); } void deleteASongFromPlaylist(Song * song) { int i; if (NULL == playlist.songs) return; for (i = 0; i < playlist.length; i++) { if (song == playlist.songs[i]) { deleteFromPlaylist(stderr, i); } } } int stopPlaylist(FILE * fp) { DEBUG("playlist: stop\n"); if (playerStop(fp) < 0) return -1; playerCloseAudio(); playlist.queued = -1; playlist_state = PLAYLIST_STATE_STOP; playlist_noGoToNext = 0; if (playlist.random) randomizeOrder(0, playlist.length - 1); return 0; } int playPlaylistOrderNumber(FILE * fp, int orderNum) { if (playerStop(fp) < 0) return -1; playlist_state = PLAYLIST_STATE_PLAY; playlist_noGoToNext = 0; playlist.queued = -1; playlist_queueError = 0; DEBUG("playlist: play %i:\"%s\"\n", orderNum, getSongUrl(playlist.songs[playlist.order[orderNum]])); if (playerPlay(fp, (playlist.songs[playlist.order[orderNum]])) < 0) { stopPlaylist(fp); return -1; } else playlist.current++; playlist.current = orderNum; return 0; } int playPlaylist(FILE * fp, int song, int stopOnError) { int i = song; clearPlayerError(); if (song == -1) { if (playlist.length == 0) return 0; if (playlist_state == PLAYLIST_STATE_PLAY) { return playerSetPause(fp, 0); } if (playlist.current >= 0 && playlist.current < playlist.length) { i = playlist.current; } else { i = 0; } } else if (song < 0 || song >= playlist.length) { commandError(fp, ACK_ERROR_NO_EXIST, "song doesn't exist: \"%i\"", song); return -1; } if (playlist.random) { if (song == -1 && playlist_state == PLAYLIST_STATE_PLAY) { randomizeOrder(0, playlist.length - 1); } else { if (song >= 0) for (i = 0; song != playlist.order[i]; i++) ; if (playlist_state == PLAYLIST_STATE_STOP) { playlist.current = 0; } swapOrder(i, playlist.current); i = playlist.current; } } playlist_stopOnError = stopOnError; playlist_errorCount = 0; return playPlaylistOrderNumber(fp, i); } int playPlaylistById(FILE * fp, int id, int stopOnError) { if (id == -1) { return playPlaylist(fp, id, stopOnError); } checkSongId(id); return playPlaylist(fp, playlist.idToPosition[id], stopOnError); } void syncCurrentPlayerDecodeMetadata(void) { Song *songPlayer = playerCurrentDecodeSong(); Song *song; int songNum; if (!songPlayer) return; if (playlist_state != PLAYLIST_STATE_PLAY) return; songNum = playlist.order[playlist.current]; song = playlist.songs[songNum]; if (song->type == SONG_TYPE_URL && 0 == strcmp(getSongUrl(song), songPlayer->url) && !mpdTagsAreEqual(song->tag, songPlayer->tag)) { if (song->tag) freeMpdTag(song->tag); song->tag = mpdTagDup(songPlayer->tag); playlist.songMod[songNum] = playlist.version; incrPlaylistVersion(); } } void syncPlayerAndPlaylist(void) { if (playlist_state != PLAYLIST_STATE_PLAY) return; if (getPlayerState() == PLAYER_STATE_STOP) playPlaylistIfPlayerStopped(); else syncPlaylistWithQueue(!playlist_queueError); syncCurrentPlayerDecodeMetadata(); } int currentSongInPlaylist(FILE * fp) { if (playlist_state != PLAYLIST_STATE_PLAY) return 0; playlist_stopOnError = 0; syncPlaylistWithQueue(0); if (playlist.current >= 0 && playlist.current < playlist.length) { return playPlaylistOrderNumber(fp, playlist.current); } else return stopPlaylist(fp);; return 0; } int nextSongInPlaylist(FILE * fp) { if (playlist_state != PLAYLIST_STATE_PLAY) return 0; syncPlaylistWithQueue(0); playlist_stopOnError = 0; if (playlist.current < playlist.length - 1) { return playPlaylistOrderNumber(fp, playlist.current + 1); } else if (playlist.length && playlist.repeat) { if (playlist.random) randomizeOrder(0, playlist.length - 1); return playPlaylistOrderNumber(fp, 0); } else { incrPlaylistCurrent(); return stopPlaylist(fp);; } return 0; } void playPlaylistIfPlayerStopped(void) { if (getPlayerState() == PLAYER_STATE_STOP) { int error = getPlayerError(); if (error == PLAYER_ERROR_NOERROR) playlist_errorCount = 0; else playlist_errorCount++; if (playlist_state == PLAYLIST_STATE_PLAY && ((playlist_stopOnError && error != PLAYER_ERROR_NOERROR) || error == PLAYER_ERROR_AUDIO || error == PLAYER_ERROR_SYSTEM || playlist_errorCount >= playlist.length)) { stopPlaylist(stderr); } else if (playlist_noGoToNext) currentSongInPlaylist(stderr); else nextSongInPlaylist(stderr); } } int getPlaylistRepeatStatus(void) { return playlist.repeat; } int getPlaylistRandomStatus(void) { return playlist.random; } int setPlaylistRepeatStatus(FILE * fp, int status) { if (status != 0 && status != 1) { commandError(fp, ACK_ERROR_ARG, "\"%i\" is not 0 or 1", status); return -1; } if (playlist_state == PLAYLIST_STATE_PLAY) { if (playlist.repeat && !status && playlist.queued == 0) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); } } playlist.repeat = status; return 0; } int moveSongInPlaylist(FILE * fp, int from, int to) { int i; Song *tmpSong; int tmpId; int queuedSong = -1; int currentSong = -1; if (from < 0 || from >= playlist.length) { commandError(fp, ACK_ERROR_NO_EXIST, "song doesn't exist: \"%i\"", from); return -1; } if (to < 0 || to >= playlist.length) { commandError(fp, ACK_ERROR_NO_EXIST, "song doesn't exist: \"%i\"", to); return -1; } if (playlist_state == PLAYLIST_STATE_PLAY) { if (playlist.queued >= 0) { queuedSong = playlist.order[playlist.queued]; } currentSong = playlist.order[playlist.current]; if (queuedSong == from || queuedSong == to || currentSong == from || currentSong == to) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); } } tmpSong = playlist.songs[from]; tmpId = playlist.positionToId[from]; /* move songs to one less in from->to */ for (i = from; i < to; i++) { moveSongFromTo(i + 1, i); } /* move songs to one more in to->from */ for (i = from; i > to; i--) { moveSongFromTo(i - 1, i); } /* put song at _to_ */ playlist.idToPosition[tmpId] = to; playlist.positionToId[to] = tmpId; playlist.songs[to] = tmpSong; playlist.songMod[to] = playlist.version; /* now deal with order */ if (playlist.random) { for (i = 0; i < playlist.length; i++) { if (playlist.order[i] > from && playlist.order[i] <= to) { playlist.order[i]--; } else if (playlist.order[i] < from && playlist.order[i] >= to) { playlist.order[i]++; } else if (from == playlist.order[i]) { playlist.order[i] = to; } } } else if (playlist.current == from) playlist.current = to; else if (playlist.current > from && playlist.current <= to) { playlist.current--; } else if (playlist.current >= to && playlist.current < from) { playlist.current++; } incrPlaylistVersion(); return 0; } int moveSongInPlaylistById(FILE * fp, int id1, int to) { checkSongId(id1); return moveSongInPlaylist(fp, playlist.idToPosition[id1], to); } static void orderPlaylist(void) { int i; if (playlist.current >= 0 && playlist.current < playlist.length) { playlist.current = playlist.order[playlist.current]; } if (playlist_state == PLAYLIST_STATE_PLAY) { if (playlist.queued >= 0) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); } } for (i = 0; i < playlist.length; i++) { playlist.order[i] = i; } } static void swapOrder(int a, int b) { int bak = playlist.order[a]; playlist.order[a] = playlist.order[b]; playlist.order[b] = bak; } static void randomizeOrder(int start, int end) { int i; int ri; DEBUG("playlist: randomize from %i to %i\n", start, end); if (playlist_state == PLAYLIST_STATE_PLAY) { if (playlist.queued >= start && playlist.queued <= end) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); } } for (i = start; i <= end; i++) { ri = random() % (end - start + 1) + start; if (ri == playlist.current) playlist.current = i; else if (i == playlist.current) playlist.current = ri; swapOrder(i, ri); } } int setPlaylistRandomStatus(FILE * fp, int status) { int statusWas = playlist.random; if (status != 0 && status != 1) { commandError(fp, ACK_ERROR_ARG, "\"%i\" is not 0 or 1", status); return -1; } playlist.random = status; if (status != statusWas) { if (playlist.random) { /*if(playlist_state==PLAYLIST_STATE_PLAY) { randomizeOrder(playlist.current+1, playlist.length-1); } else */ randomizeOrder(0, playlist.length - 1); if (playlist.current >= 0 && playlist.current < playlist.length) { swapOrder(playlist.current, 0); playlist.current = 0; } } else orderPlaylist(); } return 0; } int previousSongInPlaylist(FILE * fp) { static time_t lastTime = 0; time_t diff = time(NULL) - lastTime; lastTime += diff; if (playlist_state != PLAYLIST_STATE_PLAY) return 0; syncPlaylistWithQueue(0); if (diff && getPlayerElapsedTime() > PLAYLIST_PREV_UNLESS_ELAPSED) { return playPlaylistOrderNumber(fp, playlist.current); } else { if (playlist.current > 0) { return playPlaylistOrderNumber(fp, playlist.current - 1); } else if (playlist.repeat) { return playPlaylistOrderNumber(fp, playlist.length - 1); } else { return playPlaylistOrderNumber(fp, playlist.current); } } return 0; } int shufflePlaylist(FILE * fp) { int i; int ri; if (playlist.length > 1) { if (playlist_state == PLAYLIST_STATE_PLAY) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); /* put current playing song first */ swapSongs(0, playlist.order[playlist.current]); if (playlist.random) { int j; for (j = 0; 0 != playlist.order[j]; j++) ; playlist.current = j; } else playlist.current = 0; i = 1; } else { i = 0; playlist.current = -1; } /* shuffle the rest of the list */ for (; i < playlist.length; i++) { ri = random() % (playlist.length - 1) + 1; swapSongs(i, ri); } incrPlaylistVersion(); } return 0; } int deletePlaylist(FILE * fp, char *utf8file) { char *file = utf8ToFsCharset(utf8file); char *rfile = malloc(strlen(file) + strlen(".") + strlen(PLAYLIST_FILE_SUFFIX) + 1); char *actualFile; strcpy(rfile, file); strcat(rfile, "."); strcat(rfile, PLAYLIST_FILE_SUFFIX); free(file); if ((actualFile = rpp2app(rfile)) && isPlaylist(actualFile)) free(rfile); else { free(rfile); commandError(fp, ACK_ERROR_NO_EXIST, "playlist \"%s\" not found", utf8file); return -1; } if (unlink(actualFile) < 0) { commandError(fp, ACK_ERROR_SYSTEM, "problems deleting file", NULL); return -1; } return 0; } int savePlaylist(FILE * fp, char *utf8file) { FILE *fileP; int i; struct stat st; char *file; char *rfile; char *actualFile; char *url; if (strstr(utf8file, "/")) { commandError(fp, ACK_ERROR_ARG, "cannot save \"%s\", saving playlists to " "subdirectories is not supported", utf8file); return -1; } file = utf8ToFsCharset(utf8file); rfile = malloc(strlen(file) + strlen(".") + strlen(PLAYLIST_FILE_SUFFIX) + 1); strcpy(rfile, file); strcat(rfile, "."); strcat(rfile, PLAYLIST_FILE_SUFFIX); free(file); actualFile = rpp2app(rfile); free(rfile); if (0 == stat(actualFile, &st)) { commandError(fp, ACK_ERROR_EXIST, "a file or directory already " "exists with the name \"%s\"", utf8file); return -1; } while (!(fileP = fopen(actualFile, "w")) && errno == EINTR) ; if (fileP == NULL) { commandError(fp, ACK_ERROR_SYSTEM, "problems opening file", NULL); return -1; } for (i = 0; i < playlist.length; i++) { if (playlist_saveAbsolutePaths && playlist.songs[i]->type == SONG_TYPE_FILE) { myfprintf(fileP, "%s\n", rmp2amp(utf8ToFsCharset ((getSongUrl(playlist.songs[i]))))); } else { url = utf8ToFsCharset(getSongUrl(playlist.songs[i])); myfprintf(fileP, "%s\n", url); free(url); } } while (fclose(fileP) && errno == EINTR) ; return 0; } int getPlaylistCurrentSong(void) { if (playlist.current >= 0 && playlist.current < playlist.length) { return playlist.order[playlist.current]; } return -1; } unsigned long getPlaylistVersion(void) { return playlist.version; } int getPlaylistLength(void) { return playlist.length; } int seekSongInPlaylist(FILE * fp, int song, float time) { int i = song; if (song < 0 || song >= playlist.length) { commandError(fp, ACK_ERROR_NO_EXIST, "song doesn't exist: \"%i\"", song); return -1; } if (playlist.random) for (i = 0; song != playlist.order[i]; i++) ; clearPlayerError(); playlist_stopOnError = 1; playlist_errorCount = 0; if (playlist_state == PLAYLIST_STATE_PLAY) { if (playlist.queued >= 0) { lockPlaylistInteraction(); clearPlayerQueue(); unlockPlaylistInteraction(); } } else if (playPlaylistOrderNumber(fp, i) < 0) return -1; if (playlist.current != i) { if (playPlaylistOrderNumber(fp, i) < 0) return -1; } return playerSeek(fp, playlist.songs[playlist.order[i]], time); } int seekSongInPlaylistById(FILE * fp, int id, float time) { checkSongId(id); return seekSongInPlaylist(fp, playlist.idToPosition[id], time); } int getPlaylistSongId(int song) { return playlist.positionToId[song]; } static int PlaylistIterFunc(FILE * fp, char *utf8file, void (*IterFunc) (FILE * fp, char *utf8_file, char **errored_File)) { FILE *fileP; char s[MAXPATHLEN + 1]; int slength = 0; char *temp = utf8ToFsCharset(utf8file); char *rfile = malloc(strlen(temp) + strlen(".") + strlen(PLAYLIST_FILE_SUFFIX) + 1); char *actualFile; char *parent = parentPath(temp); int parentlen = strlen(parent); char *erroredFile = NULL; int tempInt; int commentCharFound = 0; strcpy(rfile, temp); strcat(rfile, "."); strcat(rfile, PLAYLIST_FILE_SUFFIX); free(temp); if ((actualFile = rpp2app(rfile)) && isPlaylist(actualFile)) free(rfile); else { free(rfile); commandError(fp, ACK_ERROR_NO_EXIST, "playlist \"%s\" not found", utf8file); return -1; } while (!(fileP = fopen(actualFile, "r")) && errno == EINTR) ; if (fileP == NULL) { commandError(fp, ACK_ERROR_SYSTEM, "problems opening file \"%s\"", utf8file); return -1; } while ((tempInt = fgetc(fileP)) != EOF) { s[slength] = tempInt; if (s[slength] == '\n' || s[slength] == '\0') { commentCharFound = 0; s[slength] = '\0'; if (s[0] == PLAYLIST_COMMENT) { commentCharFound = 1; } if (strncmp(s, musicDir, strlen(musicDir)) == 0) { strcpy(s, &(s[strlen(musicDir)])); } else if (parentlen) { temp = strdup(s); memset(s, 0, MAXPATHLEN + 1); strcpy(s, parent); strncat(s, "/", MAXPATHLEN - parentlen); strncat(s, temp, MAXPATHLEN - parentlen - 1); if (strlen(s) >= MAXPATHLEN) { commandError(fp, ACK_ERROR_PLAYLIST_LOAD, "\"%s\" too long", temp); free(temp); while (fclose(fileP) && errno == EINTR) ; if (erroredFile) free(erroredFile); return -1; } free(temp); } slength = 0; temp = fsCharsetToUtf8(s); if (!temp) continue; if (!commentCharFound) { /* using temp directly should be safe, * for our current IterFunction set * but just in case, we copy to s */ strcpy(s, temp); IterFunc(fp, s, &erroredFile); } free(temp); } else if (slength == MAXPATHLEN) { s[slength] = '\0'; commandError(fp, ACK_ERROR_PLAYLIST_LOAD, "line in \"%s\" is too long", utf8file); ERROR("line \"%s\" in playlist \"%s\" is too long\n", s, utf8file); while (fclose(fileP) && errno == EINTR) ; if (erroredFile) free(erroredFile); return -1; } else if (s[slength] != '\r') slength++; } while (fclose(fileP) && errno == EINTR) ; if (erroredFile) { commandError(fp, ACK_ERROR_PLAYLIST_LOAD, "can't add file \"%s\"", erroredFile); free(erroredFile); return -1; } return 0; } static void PlaylistInfoPrintInfo(FILE * fp, char *utf8file, char **erroredfile) { Song *song = getSongFromDB(utf8file); if (song) { printSongInfo(fp, song); } else { myfprintf(fp, "file: %s\n", utf8file); } } static void PlaylistInfoPrint(FILE * fp, char *utf8file, char **erroredfile) { myfprintf(fp, "file: %s\n", utf8file); } static void PlaylistLoadIterFunc(FILE * fp, char *temp, char **erroredFile) { if (!getSongFromDB(temp) && !isRemoteUrl(temp)) { } else if ((addToPlaylist(stderr, temp, 0)) < 0) { /* for windows compatibilit, convert slashes */ char *temp2 = strdup(temp); char *p = temp2; while (*p) { if (*p == '\\') *p = '/'; p++; } if ((addToPlaylist(stderr, temp2, 0)) < 0) { if (!*erroredFile) { *erroredFile = strdup(temp); } } free(temp2); } } int PlaylistInfo(FILE * fp, char *utf8file, int detail) { if (detail) { return PlaylistIterFunc(fp, utf8file, PlaylistInfoPrintInfo); } return PlaylistIterFunc(fp, utf8file, PlaylistInfoPrint); } int loadPlaylist(FILE * fp, char *utf8file) { return PlaylistIterFunc(fp, utf8file, PlaylistLoadIterFunc); }