lib/media_list.c

   1 /*****************************************************************************
   2  * media_list.c: libvlc new API media list functions
   3  *****************************************************************************
   4  * Copyright (C) 2007 VLC authors and VideoLAN
   5  *
   6  * Authors: Pierre d'Herbemont <pdherbemont # videolan.org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #include <assert.h>
  28
  29 #include <vlc/libvlc.h>
  30 #include <vlc/libvlc_picture.h>
  31 #include <vlc/libvlc_media.h>
  32 #include <vlc/libvlc_media_list.h>
  33 #include <vlc/libvlc_events.h>
  34
  35 #include <vlc_common.h>
  36
  37 #include "libvlc_internal.h"
  38 #include "media_internal.h" // libvlc_media_new_from_input_item()
  39 #include "media_list_internal.h"
  40
  41 typedef enum EventPlaceInTime {
  42     EventWillHappen,
  43     EventDidHappen
  44 } EventPlaceInTime;
  45
  46 /*
  47  * Private functions
  48  */
  49
  50
  51
  52 /**************************************************************************
  53  *       notify_item_addition (private)
  54  *
  55  * Do the appropriate action when an item is deleted.
  56  **************************************************************************/
  57 static void
  58 notify_item_addition( libvlc_media_list_t * p_mlist,
  59                       libvlc_media_t * p_md,
  60                       int index,
  61                       EventPlaceInTime event_status )
  62 {
  63     libvlc_event_t event;
  64
  65     /* Construct the event */
  66     if( event_status == EventDidHappen )
  67     {
  68         event.type = libvlc_MediaListItemAdded;
  69         event.u.media_list_item_added.item = p_md;
  70         event.u.media_list_item_added.index = index;
  71     }
  72     else /* if( event_status == EventWillHappen ) */
  73     {
  74         event.type = libvlc_MediaListWillAddItem;
  75         event.u.media_list_will_add_item.item = p_md;
  76         event.u.media_list_will_add_item.index = index;
  77     }
  78
  79     /* Send the event */
  80     libvlc_event_send( &p_mlist->event_manager, &event );
  81 }
  82
  83 /**************************************************************************
  84  *       notify_item_deletion (private)
  85  *
  86  * Do the appropriate action when an item is added.
  87  **************************************************************************/
  88 static void
  89 notify_item_deletion( libvlc_media_list_t * p_mlist,
  90                       libvlc_media_t * p_md,
  91                       int index,
  92                       EventPlaceInTime event_status )
  93 {
  94     libvlc_event_t event;
  95
  96     /* Construct the event */
  97     if( event_status == EventDidHappen )
  98     {
  99         event.type = libvlc_MediaListItemDeleted;
 100         event.u.media_list_item_deleted.item = p_md;
 101         event.u.media_list_item_deleted.index = index;
 102     }
 103     else /* if( event_status == EventWillHappen ) */
 104     {
 105         event.type = libvlc_MediaListWillDeleteItem;
 106         event.u.media_list_will_delete_item.item = p_md;
 107         event.u.media_list_will_delete_item.index = index;
 108     }
 109
 110     /* Send the event */
 111     libvlc_event_send( &p_mlist->event_manager, &event );
 112 }
 113
 114 /* LibVLC internal */
 115 void libvlc_media_list_internal_end_reached( libvlc_media_list_t * p_mlist )
 116 {
 117     libvlc_event_t event;
 118
 119     event.type = libvlc_MediaListEndReached;
 120
 121     /* Send the event */
 122     libvlc_event_send( &p_mlist->event_manager, &event );
 123 }
 124
 125 /**************************************************************************
 126  *       static mlist_is_writable (private)
 127  **************************************************************************/
 128 static inline
 129 bool mlist_is_writable( libvlc_media_list_t *p_mlist )
 130 {
 131     if( !p_mlist||p_mlist->b_read_only )
 132     {
 133         /* We are read-only from user side */
 134         libvlc_printerr( "Attempt to write a read-only media list" );
 135         return false;
 136     }
 137     return true;
 138 }
 139
 140 /*
 141  * Public libvlc functions
 142  */
 143
 144 /**************************************************************************
 145  *       libvlc_media_list_new (Public)
 146  *
 147  * Init an object.
 148  **************************************************************************/
 149 libvlc_media_list_t *
 150 libvlc_media_list_new( libvlc_instance_t * p_inst )
 151 {
 152     libvlc_media_list_t * p_mlist;
 153
 154     p_mlist = malloc(sizeof(libvlc_media_list_t));
 155     if( unlikely(p_mlist == NULL) )
 156     {
 157         libvlc_printerr( "Not enough memory" );
 158         return NULL;
 159     }
 160
 161     p_mlist->p_libvlc_instance = p_inst;
 162     libvlc_event_manager_init( &p_mlist->event_manager, p_mlist );
 163     p_mlist->b_read_only = false;
 164
 165     vlc_mutex_init( &p_mlist->object_lock );
 166     vlc_mutex_init( &p_mlist->refcount_lock ); // FIXME: spinlock?
 167
 168     vlc_array_init( &p_mlist->items );
 169     assert( p_mlist->items.i_count == 0 );
 170     p_mlist->i_refcount = 1;
 171     p_mlist->p_md = NULL;
 172     p_mlist->p_internal_md = NULL;
 173
 174     libvlc_retain( p_inst );
 175     return p_mlist;
 176 }
 177
 178 /**************************************************************************
 179  *       libvlc_media_list_release (Public)
 180  *
 181  * Release an object.
 182  **************************************************************************/
 183 void libvlc_media_list_release( libvlc_media_list_t * p_mlist )
 184 {
 185     vlc_mutex_lock( &p_mlist->refcount_lock );
 186     p_mlist->i_refcount--;
 187     if( p_mlist->i_refcount > 0 )
 188     {
 189         vlc_mutex_unlock( &p_mlist->refcount_lock );
 190         return;
 191     }
 192     vlc_mutex_unlock( &p_mlist->refcount_lock );
 193
 194     /* Refcount null, time to free */
 195
 196     libvlc_event_manager_destroy( &p_mlist->event_manager );
 197     libvlc_media_release( p_mlist->p_md );
 198
 199     for( size_t i = 0; i < vlc_array_count( &p_mlist->items ); i++ )
 200     {
 201         libvlc_media_t* p_md = vlc_array_item_at_index( &p_mlist->items, i );
 202         libvlc_media_release( p_md );
 203     }
 204
 205     vlc_array_clear( &p_mlist->items );
 206
 207     libvlc_release( p_mlist->p_libvlc_instance );
 208     free( p_mlist );
 209 }
 210
 211 /**************************************************************************
 212  *       libvlc_media_list_retain (Public)
 213  *
 214  * Increase an object refcount.
 215  **************************************************************************/
 216 void libvlc_media_list_retain( libvlc_media_list_t * p_mlist )
 217 {
 218     vlc_mutex_lock( &p_mlist->refcount_lock );
 219     p_mlist->i_refcount++;
 220     vlc_mutex_unlock( &p_mlist->refcount_lock );
 221 }
 222
 223 /**************************************************************************
 224  *       set_media (Public)
 225  **************************************************************************/
 226 void libvlc_media_list_set_media( libvlc_media_list_t * p_mlist,
 227                                   libvlc_media_t * p_md )
 228
 229 {
 230     vlc_mutex_lock( &p_mlist->object_lock );
 231     if( p_mlist->p_internal_md || !mlist_is_writable(p_mlist) )
 232     {
 233         vlc_mutex_unlock( &p_mlist->object_lock );
 234         return;
 235     }
 236     libvlc_media_release( p_mlist->p_md );
 237     libvlc_media_retain( p_md );
 238     p_mlist->p_md = p_md;
 239     vlc_mutex_unlock( &p_mlist->object_lock );
 240 }
 241
 242 /**************************************************************************
 243  *       media (Public)
 244  *
 245  * If this media_list comes is a media's subitems,
 246  * This holds the corresponding media.
 247  * This md is also seen as the information holder for the media_list.
 248  * Indeed a media_list can have meta information through this
 249  * media.
 250  **************************************************************************/
 251 libvlc_media_t *
 252 libvlc_media_list_media( libvlc_media_list_t * p_mlist )
 253 {
 254     libvlc_media_t *p_md;
 255
 256     vlc_mutex_lock( &p_mlist->object_lock );
 257     p_md = p_mlist->p_internal_md ? p_mlist->p_internal_md : p_mlist->p_md;
 258     if( p_md )
 259         libvlc_media_retain( p_md );
 260     vlc_mutex_unlock( &p_mlist->object_lock );
 261
 262     return p_md;
 263 }
 264
 265 /**************************************************************************
 266  *       libvlc_media_list_count (Public)
 267  *
 268  * Lock should be held when entering.
 269  **************************************************************************/
 270 int libvlc_media_list_count( libvlc_media_list_t * p_mlist )
 271 {
 272     return vlc_array_count( &p_mlist->items );
 273 }
 274
 275 /**************************************************************************
 276  *       libvlc_media_list_add_media (Public)
 277  *
 278  * Lock should be held when entering.
 279  **************************************************************************/
 280 int libvlc_media_list_add_media( libvlc_media_list_t * p_mlist,
 281                                  libvlc_media_t * p_md )
 282 {
 283     if( !mlist_is_writable(p_mlist) )
 284         return -1;
 285     libvlc_media_list_internal_add_media( p_mlist, p_md );
 286     return 0;
 287 }
 288
 289 /* LibVLC internal version */
 290 void libvlc_media_list_internal_add_media( libvlc_media_list_t * p_mlist,
 291                                            libvlc_media_t * p_md )
 292 {
 293     libvlc_media_retain( p_md );
 294
 295     notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items ),
 296                           EventWillHappen );
 297     vlc_array_append_or_abort( &p_mlist->items, p_md );
 298     notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items )-1,
 299                           EventDidHappen );
 300 }
 301
 302 /**************************************************************************
 303  *       libvlc_media_list_insert_media (Public)
 304  *
 305  * Lock should be hold when entering.
 306  **************************************************************************/
 307 int libvlc_media_list_insert_media( libvlc_media_list_t * p_mlist,
 308                                     libvlc_media_t * p_md,
 309                                     int index )
 310 {
 311     if( !mlist_is_writable(p_mlist) )
 312         return -1;
 313     libvlc_media_list_internal_insert_media( p_mlist, p_md, index );
 314     return 0;
 315 }
 316
 317 /* LibVLC internal version */
 318 void libvlc_media_list_internal_insert_media( libvlc_media_list_t * p_mlist,
 319                                               libvlc_media_t * p_md,
 320                                               int index )
 321 {
 322     libvlc_media_retain( p_md );
 323
 324     notify_item_addition( p_mlist, p_md, index, EventWillHappen );
 325     vlc_array_insert_or_abort( &p_mlist->items, p_md, index );
 326     notify_item_addition( p_mlist, p_md, index, EventDidHappen );
 327 }
 328
 329 /**************************************************************************
 330  *       libvlc_media_list_remove_index (Public)
 331  *
 332  * Lock should be held when entering.
 333  **************************************************************************/
 334 int libvlc_media_list_remove_index( libvlc_media_list_t * p_mlist,
 335                                      int index )
 336 {
 337     if( !mlist_is_writable(p_mlist) )
 338         return -1;
 339     return libvlc_media_list_internal_remove_index( p_mlist, index );
 340 }
 341
 342 /* LibVLC internal version */
 343 int libvlc_media_list_internal_remove_index( libvlc_media_list_t * p_mlist,
 344                                              int index )
 345 {
 346     libvlc_media_t * p_md;
 347
 348     if( (size_t) index >= vlc_array_count( &p_mlist->items ))
 349     {
 350         libvlc_printerr( "Index out of bounds" );
 351         return -1;
 352     }
 353
 354     p_md = vlc_array_item_at_index( &p_mlist->items, index );
 355
 356     notify_item_deletion( p_mlist, p_md, index, EventWillHappen );
 357     vlc_array_remove( &p_mlist->items, index );
 358     notify_item_deletion( p_mlist, p_md, index, EventDidHappen );
 359
 360     libvlc_media_release( p_md );
 361     return 0;
 362 }
 363
 364 /**************************************************************************
 365  *       libvlc_media_list_item_at_index (Public)
 366  *
 367  * Lock should be held when entering.
 368  **************************************************************************/
 369 libvlc_media_t *
 370 libvlc_media_list_item_at_index( libvlc_media_list_t * p_mlist,
 371                                  int index )
 372 {
 373     libvlc_media_t * p_md;
 374
 375     if( (size_t) index >= vlc_array_count( &p_mlist->items ))
 376     {
 377         libvlc_printerr( "Index out of bounds" );
 378         return NULL;
 379     }
 380
 381     p_md = vlc_array_item_at_index( &p_mlist->items, index );
 382     libvlc_media_retain( p_md );
 383     return p_md;
 384 }
 385
 386 /**************************************************************************
 387  *       libvlc_media_list_index_of_item (Public)
 388  *
 389  * Lock should be held when entering.
 390  * Warning: this function returns the first matching item.
 391  **************************************************************************/
 392 int libvlc_media_list_index_of_item( libvlc_media_list_t * p_mlist,
 393                                      libvlc_media_t * p_searched_md )
 394 {
 395     int idx = vlc_array_index_of_item( &p_mlist->items, p_searched_md );
 396     if( idx == -1 )
 397         libvlc_printerr( "Media not found" );
 398
 399     return idx;
 400 }
 401
 402 /**************************************************************************
 403  *       libvlc_media_list_is_readonly (Public)
 404  *
 405  * This indicates if this media list is read-only from a user point of view
 406  **************************************************************************/
 407 bool libvlc_media_list_is_readonly( libvlc_media_list_t * p_mlist )
 408 {
 409     return p_mlist->b_read_only;
 410 }
 411
 412 /**************************************************************************
 413  *       libvlc_media_list_lock (Public)
 414  *
 415  * The lock must be held in access operations. It is never used in the
 416  * Public method.
 417  **************************************************************************/
 418 void libvlc_media_list_lock( libvlc_media_list_t * p_mlist )
 419 {
 420     vlc_mutex_lock( &p_mlist->object_lock );
 421 }
 422
 423
 424 /**************************************************************************
 425  *       libvlc_media_list_unlock (Public)
 426  *
 427  * The lock must be held in access operations
 428  **************************************************************************/
 429 void libvlc_media_list_unlock( libvlc_media_list_t * p_mlist )
 430 {
 431     vlc_mutex_unlock( &p_mlist->object_lock );
 432 }
 433
 434
 435 /**************************************************************************
 436  *       libvlc_media_list_event_manager (Public)
 437  *
 438  * The p_event_manager is immutable, so you don't have to hold the lock
 439  **************************************************************************/
 440 libvlc_event_manager_t *
 441 libvlc_media_list_event_manager( libvlc_media_list_t * p_mlist )
 442 {
 443     return &p_mlist->event_manager;
 444 }