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