src/playlist_edit.c

   1 /*
   2  * Copyright (C) 2003-2010 The Music Player Daemon Project
   3  * http://www.musicpd.org
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 /*
  21  * Functions for editing the playlist (adding, removing, reordering
  22  * songs in the queue).
  23  *
  24  */
  25
  26 #include "config.h"
  27 #include "playlist_internal.h"
  28 #include "player_control.h"
  29 #include "database.h"
  30 #include "uri.h"
  31 #include "song.h"
  32 #include "idle.h"
  33
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <unistd.h>
  37 #include <stdlib.h>
  38
  39 static void playlist_increment_version(struct playlist *playlist)
  40 {
  41         queue_increment_version(&playlist->queue);
  42
  43         idle_add(IDLE_PLAYLIST);
  44 }
  45
  46 void playlist_clear(struct playlist *playlist)
  47 {
  48         playlist_stop(playlist);
  49
  50         /* make sure there are no references to allocated songs
  51            anymore */
  52         for (unsigned i = 0; i < queue_length(&playlist->queue); i++) {
  53                 const struct song *song = queue_get(&playlist->queue, i);
  54                 if (!song_in_database(song))
  55                         pc_song_deleted(song);
  56         }
  57
  58         queue_clear(&playlist->queue);
  59
  60         playlist->current = -1;
  61
  62         playlist_increment_version(playlist);
  63 }
  64
  65 #ifndef WIN32
  66 enum playlist_result
  67 playlist_append_file(struct playlist *playlist, const char *path, int uid,
  68                      unsigned *added_id)
  69 {
  70         int ret;
  71         struct stat st;
  72         struct song *song;
  73
  74         if (uid <= 0)
  75                 /* unauthenticated client */
  76                 return PLAYLIST_RESULT_DENIED;
  77
  78         ret = stat(path, &st);
  79         if (ret < 0)
  80                 return PLAYLIST_RESULT_ERRNO;
  81
  82         if (st.st_uid != (uid_t)uid && (st.st_mode & 0444) != 0444)
  83                 /* client is not owner */
  84                 return PLAYLIST_RESULT_DENIED;
  85
  86         song = song_file_load(path, NULL);
  87         if (song == NULL)
  88                 return PLAYLIST_RESULT_NO_SUCH_SONG;
  89
  90         return playlist_append_song(playlist, song, added_id);
  91 }
  92 #endif
  93
  94 enum playlist_result
  95 playlist_append_song(struct playlist *playlist,
  96                   struct song *song, unsigned *added_id)
  97 {
  98         const struct song *queued;
  99         unsigned id;
 100
 101         if (queue_is_full(&playlist->queue))
 102                 return PLAYLIST_RESULT_TOO_LARGE;
 103
 104         queued = playlist_get_queued_song(playlist);
 105
 106         id = queue_append(&playlist->queue, song);
 107
 108         if (playlist->queue.random) {
 109                 /* shuffle the new song into the list of remaining
 110                    songs to play */
 111
 112                 unsigned start;
 113                 if (playlist->queued >= 0)
 114                         start = playlist->queued + 1;
 115                 else
 116                         start = playlist->current + 1;
 117                 if (start < queue_length(&playlist->queue))
 118                         queue_shuffle_order_last(&playlist->queue, start,
 119                                                  queue_length(&playlist->queue));
 120         }
 121
 122         playlist_increment_version(playlist);
 123
 124         playlist_update_queued_song(playlist, queued);
 125
 126         if (added_id)
 127                 *added_id = id;
 128
 129         return PLAYLIST_RESULT_SUCCESS;
 130 }
 131
 132 static struct song *
 133 song_by_uri(const char *uri)
 134 {
 135         struct song *song;
 136
 137         song = db_get_song(uri);
 138         if (song != NULL)
 139                 return song;
 140
 141         if (uri_has_scheme(uri))
 142                 return song_remote_new(uri);
 143
 144         return NULL;
 145 }
 146
 147 enum playlist_result
 148 playlist_append_uri(struct playlist *playlist, const char *uri,
 149                     unsigned *added_id)
 150 {
 151         struct song *song;
 152
 153         g_debug("add to playlist: %s", uri);
 154
 155         song = song_by_uri(uri);
 156         if (song == NULL)
 157                 return PLAYLIST_RESULT_NO_SUCH_SONG;
 158
 159         return playlist_append_song(playlist, song, added_id);
 160 }
 161
 162 enum playlist_result
 163 playlist_swap_songs(struct playlist *playlist, unsigned song1, unsigned song2)
 164 {
 165         const struct song *queued;
 166
 167         if (!queue_valid_position(&playlist->queue, song1) ||
 168             !queue_valid_position(&playlist->queue, song2))
 169                 return PLAYLIST_RESULT_BAD_RANGE;
 170
 171         queued = playlist_get_queued_song(playlist);
 172
 173         queue_swap(&playlist->queue, song1, song2);
 174
 175         if (playlist->queue.random) {
 176                 /* update the queue order, so that playlist->current
 177                    still points to the current song order */
 178
 179                 queue_swap_order(&playlist->queue,
 180                                  queue_position_to_order(&playlist->queue,
 181                                                          song1),
 182                                  queue_position_to_order(&playlist->queue,
 183                                                          song2));
 184         } else {
 185                 /* correct the "current" song order */
 186
 187                 if (playlist->current == (int)song1)
 188                         playlist->current = song2;
 189                 else if (playlist->current == (int)song2)
 190                         playlist->current = song1;
 191         }
 192
 193         playlist_increment_version(playlist);
 194
 195         playlist_update_queued_song(playlist, queued);
 196
 197         return PLAYLIST_RESULT_SUCCESS;
 198 }
 199
 200 enum playlist_result
 201 playlist_swap_songs_id(struct playlist *playlist, unsigned id1, unsigned id2)
 202 {
 203         int song1 = queue_id_to_position(&playlist->queue, id1);
 204         int song2 = queue_id_to_position(&playlist->queue, id2);
 205
 206         if (song1 < 0 || song2 < 0)
 207                 return PLAYLIST_RESULT_NO_SUCH_SONG;
 208
 209         return playlist_swap_songs(playlist, song1, song2);
 210 }
 211
 212 static void
 213 playlist_delete_internal(struct playlist *playlist, unsigned song,
 214                          const struct song **queued_p)
 215 {
 216         unsigned songOrder;
 217
 218         assert(song < queue_length(&playlist->queue));
 219
 220         songOrder = queue_position_to_order(&playlist->queue, song);
 221
 222         if (playlist->playing && playlist->current == (int)songOrder) {
 223                 bool paused = pc_get_state() == PLAYER_STATE_PAUSE;
 224
 225                 /* the current song is going to be deleted: stop the player */
 226
 227                 pc_stop();
 228                 playlist->playing = false;
 229
 230                 /* see which song is going to be played instead */
 231
 232                 playlist->current = queue_next_order(&playlist->queue,
 233                                                      playlist->current);
 234                 if (playlist->current == (int)songOrder)
 235                         playlist->current = -1;
 236
 237                 if (playlist->current >= 0 && !paused)
 238                         /* play the song after the deleted one */
 239                         playlist_play_order(playlist, playlist->current);
 240                 else
 241                         /* no songs left to play, stop playback
 242                            completely */
 243                         playlist_stop(playlist);
 244
 245                 *queued_p = NULL;
 246         } else if (playlist->current == (int)songOrder)
 247                 /* there's a "current song" but we're not playing
 248                    currently - clear "current" */
 249                 playlist->current = -1;
 250
 251         /* now do it: remove the song */
 252
 253         if (!song_in_database(queue_get(&playlist->queue, song)))
 254                 pc_song_deleted(queue_get(&playlist->queue, song));
 255
 256         queue_delete(&playlist->queue, song);
 257
 258         /* update the "current" and "queued" variables */
 259
 260         if (playlist->current > (int)songOrder) {
 261                 playlist->current--;
 262         }
 263 }
 264
 265 enum playlist_result
 266 playlist_delete(struct playlist *playlist, unsigned song)
 267 {
 268         const struct song *queued;
 269
 270         if (song >= queue_length(&playlist->queue))
 271                 return PLAYLIST_RESULT_BAD_RANGE;
 272
 273         queued = playlist_get_queued_song(playlist);
 274
 275         playlist_delete_internal(playlist, song, &queued);
 276
 277         playlist_increment_version(playlist);
 278         playlist_update_queued_song(playlist, queued);
 279
 280         return PLAYLIST_RESULT_SUCCESS;
 281 }
 282
 283 enum playlist_result
 284 playlist_delete_range(struct playlist *playlist, unsigned start, unsigned end)
 285 {
 286         const struct song *queued;
 287
 288         if (start >= queue_length(&playlist->queue))
 289                 return PLAYLIST_RESULT_BAD_RANGE;
 290
 291         if (end > queue_length(&playlist->queue))
 292                 end = queue_length(&playlist->queue);
 293
 294         if (start >= end)
 295                 return PLAYLIST_RESULT_SUCCESS;
 296
 297         queued = playlist_get_queued_song(playlist);
 298
 299         do {
 300                 playlist_delete_internal(playlist, --end, &queued);
 301         } while (end != start);
 302
 303         playlist_increment_version(playlist);
 304         playlist_update_queued_song(playlist, queued);
 305
 306         return PLAYLIST_RESULT_SUCCESS;
 307 }
 308
 309 enum playlist_result
 310 playlist_delete_id(struct playlist *playlist, unsigned id)
 311 {
 312         int song = queue_id_to_position(&playlist->queue, id);
 313         if (song < 0)
 314                 return PLAYLIST_RESULT_NO_SUCH_SONG;
 315
 316         return playlist_delete(playlist, song);
 317 }
 318
 319 void
 320 playlist_delete_song(struct playlist *playlist, const struct song *song)
 321 {
 322         for (int i = queue_length(&playlist->queue) - 1; i >= 0; --i)
 323                 if (song == queue_get(&playlist->queue, i))
 324                         playlist_delete(playlist, i);
 325
 326         pc_song_deleted(song);
 327 }
 328
 329 enum playlist_result
 330 playlist_move_range(struct playlist *playlist,
 331                     unsigned start, unsigned end, int to)
 332 {
 333         const struct song *queued;
 334         int currentSong;
 335
 336         if (!queue_valid_position(&playlist->queue, start) ||
 337                 !queue_valid_position(&playlist->queue, end - 1))
 338                 return PLAYLIST_RESULT_BAD_RANGE;
 339
 340         if ((to >= 0 && to + end - start - 1 >= queue_length(&playlist->queue)) ||
 341             (to < 0 && abs(to) > (int)queue_length(&playlist->queue)))
 342                 return PLAYLIST_RESULT_BAD_RANGE;
 343
 344         if ((int)start == to)
 345                 /* nothing happens */
 346                 return PLAYLIST_RESULT_SUCCESS;
 347
 348         queued = playlist_get_queued_song(playlist);
 349
 350         /*
 351          * (to < 0) => move to offset from current song
 352          * (-playlist.length == to) => move to position BEFORE current song
 353          */
 354         currentSong = playlist->current >= 0
 355                 ? (int)queue_order_to_position(&playlist->queue,
 356                                               playlist->current)
 357                 : -1;
 358         if (to < 0 && playlist->current >= 0) {
 359                 if (start <= (unsigned)currentSong && (unsigned)currentSong <= end)
 360                         /* no-op, can't be moved to offset of itself */
 361                         return PLAYLIST_RESULT_SUCCESS;
 362                 to = (currentSong + abs(to)) % queue_length(&playlist->queue);
 363                 if (start < (unsigned)to)
 364                         to--;
 365         }
 366
 367         queue_move_range(&playlist->queue, start, end, to);
 368
 369         if (!playlist->queue.random) {
 370                 /* update current/queued */
 371                 if ((int)start <= playlist->current &&
 372                     (unsigned)playlist->current < end)
 373                         playlist->current += to - start;
 374                 else if (playlist->current >= (int)end &&
 375                          playlist->current <= to) {
 376                         playlist->current -= end - start;
 377                 } else if (playlist->current >= to &&
 378                            playlist->current < (int)start) {
 379                         playlist->current += end - start;
 380                 }
 381         }
 382
 383         playlist_increment_version(playlist);
 384
 385         playlist_update_queued_song(playlist, queued);
 386
 387         return PLAYLIST_RESULT_SUCCESS;
 388 }
 389
 390 enum playlist_result
 391 playlist_move_id(struct playlist *playlist, unsigned id1, int to)
 392 {
 393         int song = queue_id_to_position(&playlist->queue, id1);
 394         if (song < 0)
 395                 return PLAYLIST_RESULT_NO_SUCH_SONG;
 396
 397         return playlist_move_range(playlist, song, song+1, to);
 398 }
 399
 400 void
 401 playlist_shuffle(struct playlist *playlist, unsigned start, unsigned end)
 402 {
 403         const struct song *queued;
 404
 405         if (end > queue_length(&playlist->queue))
 406                 /* correct the "end" offset */
 407                 end = queue_length(&playlist->queue);
 408
 409         if ((start+1) >= end)
 410                 /* needs at least two entries. */
 411                 return;
 412
 413         queued = playlist_get_queued_song(playlist);
 414         if (playlist->playing && playlist->current >= 0) {
 415                 unsigned current_position;
 416                 current_position = queue_order_to_position(&playlist->queue,
 417                                                            playlist->current);
 418
 419                 if (current_position >= start && current_position < end)
 420                 {
 421                         /* put current playing song first */
 422                         queue_swap(&playlist->queue, start, current_position);
 423
 424                         if (playlist->queue.random) {
 425                                 playlist->current =
 426                                         queue_position_to_order(&playlist->queue, start);
 427                         } else
 428                                 playlist->current = start;
 429
 430                         /* start shuffle after the current song */
 431                         start++;
 432                 }
 433         } else {
 434                 /* no playback currently: reset playlist->current */
 435
 436                 playlist->current = -1;
 437         }
 438
 439         queue_shuffle_range(&playlist->queue, start, end);
 440
 441         playlist_increment_version(playlist);
 442
 443         playlist_update_queued_song(playlist, queued);
 444 }