No need to check for a NULL as libvlc_media_release is checking.
[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     libvlc_media_release( p_mlist->p_md );
205
206     for ( i = 0; i < vlc_array_count( &p_mlist->items ); i++ )
207     {
208         p_md = vlc_array_item_at_index( &p_mlist->items, i );
209         libvlc_media_release( p_md );
210     }
211
212     vlc_mutex_destroy( &p_mlist->object_lock );
213     vlc_array_clear( &p_mlist->items );
214
215     free( p_mlist );
216 }
217
218 /**************************************************************************
219  *       libvlc_media_list_retain (Public)
220  *
221  * Increase an object refcount.
222  **************************************************************************/
223 void libvlc_media_list_retain( libvlc_media_list_t * p_mlist )
224 {
225     vlc_mutex_lock( &p_mlist->object_lock );
226     p_mlist->i_refcount++;
227     vlc_mutex_unlock( &p_mlist->object_lock );
228 }
229
230
231 /**************************************************************************
232  *       add_file_content (Public)
233  **************************************************************************/
234 void
235 libvlc_media_list_add_file_content( libvlc_media_list_t * p_mlist,
236                                     const char * psz_uri,
237                                     libvlc_exception_t * p_e )
238 {
239     input_item_t * p_input_item;
240     libvlc_media_t * p_md;
241
242     p_input_item = input_item_NewExt(
243                            p_mlist->p_libvlc_instance->p_libvlc_int, psz_uri,
244                                          _("Media Library"), 0, NULL, 0, -1 );
245
246     if( !p_input_item )
247     {
248         libvlc_exception_raise( p_e, "Can't create an input item" );
249         return;
250     }
251
252     p_md = libvlc_media_new_from_input_item(
253             p_mlist->p_libvlc_instance,
254             p_input_item, p_e );
255
256     if( !p_md )
257     {
258         vlc_gc_decref( p_input_item );
259         return;
260     }
261
262     libvlc_media_list_add_media( p_mlist, p_md, p_e );
263     if( libvlc_exception_raised( p_e ) )
264         return;
265
266     input_Read( p_mlist->p_libvlc_instance->p_libvlc_int, p_input_item, true );
267
268     return;
269 }
270
271 /**************************************************************************
272  *       set_media (Public)
273  **************************************************************************/
274 void libvlc_media_list_set_media( libvlc_media_list_t * p_mlist,
275                                              libvlc_media_t * p_md,
276                                              libvlc_exception_t * p_e)
277
278 {
279     VLC_UNUSED(p_e);
280     vlc_mutex_lock( &p_mlist->object_lock );
281     libvlc_media_release( p_mlist->p_md );
282     libvlc_media_retain( p_md );
283     p_mlist->p_md = p_md;
284     vlc_mutex_unlock( &p_mlist->object_lock );
285 }
286
287 /**************************************************************************
288  *       media (Public)
289  *
290  * If this media_list comes is a media's subitems,
291  * This holds the corresponding media.
292  * This md is also seen as the information holder for the media_list.
293  * Indeed a media_list can have meta information through this
294  * media.
295  **************************************************************************/
296 libvlc_media_t *
297 libvlc_media_list_media( libvlc_media_list_t * p_mlist,
298                                     libvlc_exception_t * p_e)
299 {
300     libvlc_media_t *p_md;
301     VLC_UNUSED(p_e);
302
303     vlc_mutex_lock( &p_mlist->object_lock );
304     p_md = p_mlist->p_md;
305     if( p_md )
306         libvlc_media_retain( p_md );
307     vlc_mutex_unlock( &p_mlist->object_lock );
308
309     return p_md;
310 }
311
312 /**************************************************************************
313  *       libvlc_media_list_count (Public)
314  *
315  * Lock should be hold when entering.
316  **************************************************************************/
317 int libvlc_media_list_count( libvlc_media_list_t * p_mlist,
318                              libvlc_exception_t * p_e )
319 {
320     VLC_UNUSED(p_e);
321     return vlc_array_count( &p_mlist->items );
322 }
323
324 /**************************************************************************
325  *       libvlc_media_list_add_media (Public)
326  *
327  * Lock should be held when entering.
328  **************************************************************************/
329 void libvlc_media_list_add_media(
330                                    libvlc_media_list_t * p_mlist,
331                                    libvlc_media_t * p_md,
332                                    libvlc_exception_t * p_e )
333 {
334     if( mlist_is_writable(p_mlist,p_e) )
335         _libvlc_media_list_add_media( p_mlist, p_md, p_e );
336 }
337
338 /* LibVLC internal version */
339 void _libvlc_media_list_add_media(
340                                    libvlc_media_list_t * p_mlist,
341                                    libvlc_media_t * p_md,
342                                    libvlc_exception_t * p_e )
343 {
344     VLC_UNUSED(p_e);
345     libvlc_media_retain( p_md );
346
347     notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items ),
348                           EventWillHappen );
349     vlc_array_append( &p_mlist->items, p_md );
350     notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items )-1,
351                           EventDidHappen );
352 }
353
354 /**************************************************************************
355  *       libvlc_media_list_insert_media (Public)
356  *
357  * Lock should be hold when entering.
358  **************************************************************************/
359 void libvlc_media_list_insert_media(
360                                    libvlc_media_list_t * p_mlist,
361                                    libvlc_media_t * p_md,
362                                    int index,
363                                    libvlc_exception_t * p_e )
364 {
365     if( mlist_is_writable(p_mlist,p_e) )
366         _libvlc_media_list_insert_media( p_mlist, p_md, index, p_e );
367 }
368
369 /* LibVLC internal version */
370 void _libvlc_media_list_insert_media(
371                                    libvlc_media_list_t * p_mlist,
372                                    libvlc_media_t * p_md,
373                                    int index,
374                                    libvlc_exception_t * p_e )
375 {
376     VLC_UNUSED(p_e);
377     libvlc_media_retain( p_md );
378
379     notify_item_addition( p_mlist, p_md, index, EventWillHappen );
380     vlc_array_insert( &p_mlist->items, p_md, index );
381     notify_item_addition( p_mlist, p_md, index, EventDidHappen );
382 }
383
384 /**************************************************************************
385  *       libvlc_media_list_remove_index (Public)
386  *
387  * Lock should be held when entering.
388  **************************************************************************/
389 void libvlc_media_list_remove_index( libvlc_media_list_t * p_mlist,
390                                      int index,
391                                      libvlc_exception_t * p_e )
392 {
393     if( mlist_is_writable(p_mlist,p_e) )
394         _libvlc_media_list_remove_index( p_mlist, index, p_e );
395 }
396
397 /* LibVLC internal version */
398 void _libvlc_media_list_remove_index( libvlc_media_list_t * p_mlist,
399                                      int index,
400                                      libvlc_exception_t * p_e )
401 {
402     libvlc_media_t * p_md;
403
404     if( index < 0 || index >= vlc_array_count( &p_mlist->items ))
405     {
406         libvlc_exception_raise( p_e, "Index out of bounds");
407         return;
408     }
409
410     p_md = vlc_array_item_at_index( &p_mlist->items, index );
411
412     notify_item_deletion( p_mlist, p_md, index, EventWillHappen );
413     vlc_array_remove( &p_mlist->items, index );
414     notify_item_deletion( p_mlist, p_md, index, EventDidHappen );
415
416     libvlc_media_release( p_md );
417 }
418
419 /**************************************************************************
420  *       libvlc_media_list_item_at_index (Public)
421  *
422  * Lock should be held when entering.
423  **************************************************************************/
424 libvlc_media_t *
425 libvlc_media_list_item_at_index( libvlc_media_list_t * p_mlist,
426                                  int index,
427                                  libvlc_exception_t * p_e )
428 {
429     libvlc_media_t * p_md;
430
431     if( index < 0 || index >= vlc_array_count( &p_mlist->items ))
432     {
433         libvlc_exception_raise( p_e, "Index out of bounds");
434         return NULL;
435     }
436
437     p_md = vlc_array_item_at_index( &p_mlist->items, index );
438     libvlc_media_retain( p_md );
439     return p_md;
440 }
441
442 /**************************************************************************
443  *       libvlc_media_list_index_of_item (Public)
444  *
445  * Lock should be held when entering.
446  * Warning: this function returns the first matching item.
447  **************************************************************************/
448 int libvlc_media_list_index_of_item( libvlc_media_list_t * p_mlist,
449                                      libvlc_media_t * p_searched_md,
450                                      libvlc_exception_t * p_e )
451 {
452     VLC_UNUSED(p_e);
453
454     libvlc_media_t * p_md;
455     int i;
456     for ( i = 0; i < vlc_array_count( &p_mlist->items ); i++ )
457     {
458         p_md = vlc_array_item_at_index( &p_mlist->items, i );
459         if( p_searched_md == p_md )
460             return i;
461     }
462     return -1;
463 }
464
465 /**************************************************************************
466  *       libvlc_media_list_is_readonly (Public)
467  *
468  * This indicates if this media list is read-only from a user point of view
469  **************************************************************************/
470 int libvlc_media_list_is_readonly( libvlc_media_list_t * p_mlist )
471 {
472     return p_mlist->b_read_only;
473 }
474
475 /**************************************************************************
476  *       libvlc_media_list_lock (Public)
477  *
478  * The lock must be held in access operations. It is never used in the
479  * Public method.
480  **************************************************************************/
481 void libvlc_media_list_lock( libvlc_media_list_t * p_mlist )
482 {
483     vlc_mutex_lock( &p_mlist->object_lock );
484 }
485
486
487 /**************************************************************************
488  *       libvlc_media_list_unlock (Public)
489  *
490  * The lock must be held in access operations
491  **************************************************************************/
492 void libvlc_media_list_unlock( libvlc_media_list_t * p_mlist )
493 {
494     vlc_mutex_unlock( &p_mlist->object_lock );
495 }
496
497
498 /**************************************************************************
499  *       libvlc_media_list_p_event_manager (Public)
500  *
501  * The p_event_manager is immutable, so you don't have to hold the lock
502  **************************************************************************/
503 libvlc_event_manager_t *
504 libvlc_media_list_event_manager( libvlc_media_list_t * p_mlist,
505                                     libvlc_exception_t * p_e )
506 {
507     VLC_UNUSED(p_e);
508     return p_mlist->p_event_manager;
509 }