src/playlist/content.c

   1 /*****************************************************************************
   2  * playlist/content.c
   3  *****************************************************************************
   4  * Copyright (C) 2018 VLC authors and VideoLAN
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include "content.h"
  26
  27 #include "control.h"
  28 #include "item.h"
  29 #include "notify.h"
  30 #include "playlist.h"
  31
  32 void
  33 vlc_playlist_ClearItems(vlc_playlist_t *playlist)
  34 {
  35     vlc_playlist_item_t *item;
  36     vlc_vector_foreach(item, &playlist->items)
  37         vlc_playlist_item_Release(item);
  38     vlc_vector_clear(&playlist->items);
  39 }
  40
  41 static void
  42 vlc_playlist_ItemsReset(vlc_playlist_t *playlist)
  43 {
  44     if (playlist->order == VLC_PLAYLIST_PLAYBACK_ORDER_RANDOM)
  45         randomizer_Clear(&playlist->randomizer);
  46
  47     struct vlc_playlist_state state;
  48     vlc_playlist_state_Save(playlist, &state);
  49
  50     playlist->current = -1;
  51     playlist->has_prev = vlc_playlist_ComputeHasPrev(playlist);
  52     playlist->has_next = vlc_playlist_ComputeHasNext(playlist);
  53
  54     vlc_playlist_Notify(playlist, on_items_reset, playlist->items.data,
  55                    playlist->items.size);
  56     vlc_playlist_state_NotifyChanges(playlist, &state);
  57 }
  58
  59 static void
  60 vlc_playlist_ItemsInserted(vlc_playlist_t *playlist, size_t index, size_t count)
  61 {
  62     if (playlist->order == VLC_PLAYLIST_PLAYBACK_ORDER_RANDOM)
  63         randomizer_Add(&playlist->randomizer,
  64                        &playlist->items.data[index], count);
  65
  66     struct vlc_playlist_state state;
  67     vlc_playlist_state_Save(playlist, &state);
  68
  69     if (playlist->current >= (ssize_t) index)
  70         playlist->current += count;
  71     playlist->has_prev = vlc_playlist_ComputeHasPrev(playlist);
  72     playlist->has_next = vlc_playlist_ComputeHasNext(playlist);
  73
  74     vlc_playlist_item_t **items = &playlist->items.data[index];
  75     vlc_playlist_Notify(playlist, on_items_added, index, items, count);
  76     vlc_playlist_state_NotifyChanges(playlist, &state);
  77 }
  78
  79 static void
  80 vlc_playlist_ItemsMoved(vlc_playlist_t *playlist, size_t index, size_t count,
  81                         size_t target)
  82 {
  83     struct vlc_playlist_state state;
  84     vlc_playlist_state_Save(playlist, &state);
  85
  86     if (playlist->current != -1) {
  87         size_t current = (size_t) playlist->current;
  88         if (index < target)
  89         {
  90             if (current >= index && current < index + count)
  91                 /* current item belongs to the moved block */
  92                 playlist->current += target - index;
  93             else if (current >= index + count && current < target + count)
  94                 /* current item was shifted backwards to the moved block */
  95                 playlist->current -= count;
  96             /* else the current item does not move */
  97         }
  98         else
  99         {
 100             if (current >= index && current < index + count)
 101                 /* current item belongs to the moved block */
 102                 playlist->current -= index - target;
 103             else if (current >= target && current < index)
 104                 /* current item was shifted forward to the moved block */
 105                 playlist->current += count;
 106             /* else the current item does not move */
 107         }
 108     }
 109
 110     playlist->has_prev = vlc_playlist_ComputeHasPrev(playlist);
 111     playlist->has_next = vlc_playlist_ComputeHasNext(playlist);
 112
 113     vlc_playlist_Notify(playlist, on_items_moved, index, count, target);
 114     vlc_playlist_state_NotifyChanges(playlist, &state);
 115 }
 116
 117 static void
 118 vlc_playlist_ItemsRemoving(vlc_playlist_t *playlist, size_t index, size_t count)
 119 {
 120     if (playlist->order == VLC_PLAYLIST_PLAYBACK_ORDER_RANDOM)
 121         randomizer_Remove(&playlist->randomizer,
 122                           &playlist->items.data[index], count);
 123 }
 124
 125 /* return whether the current media has changed */
 126 static bool
 127 vlc_playlist_ItemsRemoved(vlc_playlist_t *playlist, size_t index, size_t count)
 128 {
 129     struct vlc_playlist_state state;
 130     vlc_playlist_state_Save(playlist, &state);
 131
 132     bool current_media_changed = false;
 133     if (playlist->current != -1) {
 134         size_t current = (size_t) playlist->current;
 135         if (current >= index && current < index + count) {
 136             /* current item has been removed */
 137             if (index + count < playlist->items.size) {
 138                 /* select the first item after the removed block */
 139                 playlist->current = index;
 140             } else {
 141                 /* no more items */
 142                 playlist->current = -1;
 143             }
 144             current_media_changed = true;
 145         } else if (current >= index + count) {
 146             playlist->current -= count;
 147         }
 148     }
 149     playlist->has_prev = vlc_playlist_ComputeHasPrev(playlist);
 150     playlist->has_next = vlc_playlist_ComputeHasNext(playlist);
 151
 152     vlc_playlist_Notify(playlist, on_items_removed, index, count);
 153     vlc_playlist_state_NotifyChanges(playlist, &state);
 154
 155     return current_media_changed;
 156 }
 157
 158 size_t
 159 vlc_playlist_Count(vlc_playlist_t *playlist)
 160 {
 161     vlc_playlist_AssertLocked(playlist);
 162     return playlist->items.size;
 163 }
 164
 165 vlc_playlist_item_t *
 166 vlc_playlist_Get(vlc_playlist_t *playlist, size_t index)
 167 {
 168     vlc_playlist_AssertLocked(playlist);
 169     return playlist->items.data[index];
 170 }
 171
 172 ssize_t
 173 vlc_playlist_IndexOf(vlc_playlist_t *playlist, const vlc_playlist_item_t *item)
 174 {
 175     vlc_playlist_AssertLocked(playlist);
 176
 177     ssize_t index;
 178     vlc_vector_index_of(&playlist->items, item, &index);
 179     return index;
 180 }
 181
 182 ssize_t
 183 vlc_playlist_IndexOfMedia(vlc_playlist_t *playlist, const input_item_t *media)
 184 {
 185     vlc_playlist_AssertLocked(playlist);
 186
 187     playlist_item_vector_t *items = &playlist->items;
 188     for (size_t i = 0; i < items->size; ++i)
 189         if (items->data[i]->media == media)
 190             return i;
 191     return -1;
 192 }
 193
 194 void
 195 vlc_playlist_Clear(vlc_playlist_t *playlist)
 196 {
 197     vlc_playlist_AssertLocked(playlist);
 198
 199     int ret = vlc_player_SetCurrentMedia(playlist->player, NULL);
 200     VLC_UNUSED(ret); /* what could we do? */
 201
 202     vlc_playlist_ClearItems(playlist);
 203     vlc_playlist_ItemsReset(playlist);
 204 }
 205
 206 static int
 207 vlc_playlist_MediaToItems(input_item_t *const media[], size_t count,
 208                           vlc_playlist_item_t *items[])
 209 {
 210     size_t i;
 211     for (i = 0; i < count; ++i)
 212     {
 213         items[i] = vlc_playlist_item_New(media[i]);
 214         if (unlikely(!items[i]))
 215             break;
 216     }
 217     if (i < count)
 218     {
 219         /* allocation failure, release partial items */
 220         while (i)
 221             vlc_playlist_item_Release(items[--i]);
 222         return VLC_ENOMEM;
 223     }
 224     return VLC_SUCCESS;
 225 }
 226
 227 int
 228 vlc_playlist_Insert(vlc_playlist_t *playlist, size_t index,
 229                     input_item_t *const media[], size_t count)
 230 {
 231     vlc_playlist_AssertLocked(playlist);
 232     assert(index <= playlist->items.size);
 233
 234     /* make space in the vector */
 235     if (!vlc_vector_insert_hole(&playlist->items, index, count))
 236         return VLC_ENOMEM;
 237
 238     /* create playlist items in place */
 239     int ret = vlc_playlist_MediaToItems(media, count,
 240                                         &playlist->items.data[index]);
 241     if (ret != VLC_SUCCESS)
 242     {
 243         /* we were optimistic, it failed, restore the vector state */
 244         vlc_vector_remove_slice(&playlist->items, index, count);
 245         return ret;
 246     }
 247
 248     vlc_playlist_ItemsInserted(playlist, index, count);
 249     vlc_player_InvalidateNextMedia(playlist->player);
 250
 251     return VLC_SUCCESS;
 252 }
 253
 254 void
 255 vlc_playlist_Move(vlc_playlist_t *playlist, size_t index, size_t count,
 256                   size_t target)
 257 {
 258     vlc_playlist_AssertLocked(playlist);
 259     assert(index + count <= playlist->items.size);
 260     assert(target + count <= playlist->items.size);
 261
 262     vlc_vector_move_slice(&playlist->items, index, count, target);
 263
 264     vlc_playlist_ItemsMoved(playlist, index, count, target);
 265     vlc_player_InvalidateNextMedia(playlist->player);
 266 }
 267
 268 void
 269 vlc_playlist_Remove(vlc_playlist_t *playlist, size_t index, size_t count)
 270 {
 271     vlc_playlist_AssertLocked(playlist);
 272     assert(index < playlist->items.size);
 273
 274     vlc_playlist_ItemsRemoving(playlist, index, count);
 275
 276     for (size_t i = 0; i < count; ++i)
 277         vlc_playlist_item_Release(playlist->items.data[index + i]);
 278
 279     vlc_vector_remove_slice(&playlist->items, index, count);
 280
 281     bool current_media_changed = vlc_playlist_ItemsRemoved(playlist, index,
 282                                                            count);
 283     if (current_media_changed)
 284         vlc_playlist_SetCurrentMedia(playlist, playlist->current);
 285     else
 286         vlc_player_InvalidateNextMedia(playlist->player);
 287 }
 288
 289 int
 290 vlc_playlist_Expand(vlc_playlist_t *playlist, size_t index,
 291                     input_item_t *const media[], size_t count)
 292 {
 293     vlc_playlist_AssertLocked(playlist);
 294     assert(index < playlist->items.size);
 295
 296     vlc_playlist_RemoveOne(playlist, index);
 297     return vlc_playlist_Insert(playlist, index, media, count);
 298 }