db69555dc0a5b395e6f4605c0f391c89b4d1894e
[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 /*
30  * Private functions
31  */
32
33
34
35 /**************************************************************************
36  *       notify_item_addition (private)
37  *
38  * Do the appropriate action when an item is deleted.
39  **************************************************************************/
40 static void
41 notify_item_addition( libvlc_media_list_t * p_mlist,
42                       libvlc_media_descriptor_t * p_md,
43                       int index )
44 {
45     libvlc_event_t event;
46
47     /* Construct the event */
48     event.type = libvlc_MediaListItemAdded;
49     event.u.media_list_item_added.item = p_md;
50     event.u.media_list_item_added.index = index;
51
52     /* Send the event */
53     libvlc_event_send( p_mlist->p_event_manager, &event );
54 }
55
56 /**************************************************************************
57  *       notify_item_deletion (private)
58  *
59  * Do the appropriate action when an item is added.
60  **************************************************************************/
61 static void
62 notify_item_deletion( libvlc_media_list_t * p_mlist,
63                       libvlc_media_descriptor_t * p_md,
64                       int index )
65 {
66     libvlc_event_t event;
67
68     /* Construct the event */
69     event.type = libvlc_MediaListItemDeleted;
70     event.u.media_list_item_deleted.item = p_md;
71     event.u.media_list_item_deleted.index = index;
72
73     /* Send the event */
74     libvlc_event_send( p_mlist->p_event_manager, &event );
75 }
76
77 /*
78  * Public libvlc functions
79  */
80
81 /**************************************************************************
82  *       libvlc_media_list_new (Public)
83  *
84  * Init an object.
85  **************************************************************************/
86 libvlc_media_list_t *
87 libvlc_media_list_new( libvlc_instance_t * p_inst,
88                        libvlc_exception_t * p_e )
89 {
90     libvlc_media_list_t * p_mlist;
91
92     p_mlist = malloc(sizeof(libvlc_media_list_t));
93
94     if( !p_mlist )
95         return NULL;
96  
97     p_mlist->p_libvlc_instance = p_inst;
98     p_mlist->p_event_manager = libvlc_event_manager_new( p_mlist, p_inst, p_e );
99
100     /* Code for that one should be handled in flat_media_list.c */
101     p_mlist->p_flat_mlist = NULL;
102
103     libvlc_event_manager_register_event_type( p_mlist->p_event_manager,
104             libvlc_MediaListItemAdded, p_e );
105     libvlc_event_manager_register_event_type( p_mlist->p_event_manager,
106             libvlc_MediaListItemDeleted, p_e );
107
108     if( libvlc_exception_raised( p_e ) )
109     {
110         libvlc_event_manager_release( p_mlist->p_event_manager );
111         free( p_mlist );
112         return NULL;
113     }
114
115     vlc_mutex_init( p_inst->p_libvlc_int, &p_mlist->object_lock );
116  
117     ARRAY_INIT(p_mlist->items);
118     p_mlist->i_refcount = 1;
119     p_mlist->p_md = NULL;
120
121     return p_mlist;
122 }
123
124 /**************************************************************************
125  *       libvlc_media_list_release (Public)
126  *
127  * Release an object.
128  **************************************************************************/
129 void libvlc_media_list_release( libvlc_media_list_t * p_mlist )
130 {
131     libvlc_media_descriptor_t * p_md;
132
133     vlc_mutex_lock( &p_mlist->object_lock );
134     p_mlist->i_refcount--;
135     if( p_mlist->i_refcount > 0 )
136     {
137         vlc_mutex_unlock( &p_mlist->object_lock );
138         return;
139     }
140     vlc_mutex_unlock( &p_mlist->object_lock );
141
142     /* Refcount null, time to free */
143
144     /* Handled in flat_media_list.c */
145     libvlc_media_list_flat_media_list_release( p_mlist );
146
147     libvlc_event_manager_release( p_mlist->p_event_manager );
148
149     if( p_mlist->p_md )
150         libvlc_media_descriptor_release( p_mlist->p_md );
151
152     FOREACH_ARRAY( p_md, p_mlist->items )
153         libvlc_media_descriptor_release( p_md );
154     FOREACH_END()
155  
156     free( p_mlist );
157 }
158
159 /**************************************************************************
160  *       libvlc_media_list_retain (Public)
161  *
162  * Increase an object refcount.
163  **************************************************************************/
164 void libvlc_media_list_retain( libvlc_media_list_t * p_mlist )
165 {
166     vlc_mutex_lock( &p_mlist->object_lock );
167     p_mlist->i_refcount++;
168     vlc_mutex_unlock( &p_mlist->object_lock );
169 }
170
171
172 /**************************************************************************
173  *       add_file_content (Public)
174  **************************************************************************/
175 void
176 libvlc_media_list_add_file_content( libvlc_media_list_t * p_mlist,
177                                     const char * psz_uri,
178                                     libvlc_exception_t * p_e )
179 {
180     input_item_t * p_input_item;
181     libvlc_media_descriptor_t * p_md;
182
183     p_input_item = input_ItemNewExt( p_mlist->p_libvlc_instance->p_libvlc_int, psz_uri,
184                                 _("Media Library"), 0, NULL, -1 );
185
186     if( !p_input_item )
187     {
188         libvlc_exception_raise( p_e, "Can't create an input item" );
189         return;
190     }
191
192     p_md = libvlc_media_descriptor_new_from_input_item(
193             p_mlist->p_libvlc_instance,
194             p_input_item, p_e );
195
196     if( !p_md )
197     {
198         vlc_gc_decref( p_input_item );
199         return;
200     }
201
202     libvlc_media_list_add_media_descriptor( p_mlist, p_md, p_e );
203     if( libvlc_exception_raised( p_e ) )
204         return;
205
206     input_Read( p_mlist->p_libvlc_instance->p_libvlc_int, p_input_item, VLC_TRUE );
207
208     return;
209 }
210
211 /**************************************************************************
212  *       set_media_descriptor (Public)
213  **************************************************************************/
214 void libvlc_media_list_set_media_descriptor( libvlc_media_list_t * p_mlist,
215                                              libvlc_media_descriptor_t * p_md,
216                                              libvlc_exception_t * p_e)
217
218 {
219     (void)p_e;
220     vlc_mutex_lock( &p_mlist->object_lock );
221     if( p_mlist->p_md )
222         libvlc_media_descriptor_release( p_mlist->p_md );
223     libvlc_media_descriptor_retain( p_md );
224     p_mlist->p_md = p_md;
225     vlc_mutex_unlock( &p_mlist->object_lock );
226 }
227
228 /**************************************************************************
229  *       media_descriptor (Public)
230  *
231  * If this media_list comes is a media_descriptor's subitems,
232  * This holds the corresponding media_descriptor.
233  * This md is also seen as the information holder for the media_list.
234  * Indeed a media_list can have meta information through this
235  * media_descriptor.
236  **************************************************************************/
237 libvlc_media_descriptor_t *
238 libvlc_media_list_media_descriptor( libvlc_media_list_t * p_mlist,
239                                     libvlc_exception_t * p_e)
240 {
241     libvlc_media_descriptor_t *p_md;
242     (void)p_e;
243
244     vlc_mutex_lock( &p_mlist->object_lock );
245     p_md = p_mlist->p_md;
246     if( p_md )
247         libvlc_media_descriptor_retain( p_md );
248     vlc_mutex_unlock( &p_mlist->object_lock );
249
250     return p_md;
251 }
252
253 /**************************************************************************
254  *       libvlc_media_list_count (Public)
255  *
256  * Lock should be hold when entering.
257  **************************************************************************/
258 int libvlc_media_list_count( libvlc_media_list_t * p_mlist,
259                              libvlc_exception_t * p_e )
260 {
261     (void)p_e;
262     return p_mlist->items.i_size;
263 }
264
265 /**************************************************************************
266  *       libvlc_media_list_add_media_descriptor (Public)
267  *
268  * Lock should be hold when entering.
269  **************************************************************************/
270 void libvlc_media_list_add_media_descriptor(
271                                    libvlc_media_list_t * p_mlist,
272                                    libvlc_media_descriptor_t * p_md,
273                                    libvlc_exception_t * p_e )
274 {
275     (void)p_e;
276     libvlc_media_descriptor_retain( p_md );
277     ARRAY_INSERT( p_mlist->items, p_md, p_mlist->items.i_size );
278     notify_item_addition( p_mlist, p_md, p_mlist->items.i_size-1 );
279 }
280
281 /**************************************************************************
282  *       libvlc_media_list_insert_media_descriptor (Public)
283  *
284  * Lock should be hold when entering.
285  **************************************************************************/
286 void libvlc_media_list_insert_media_descriptor(
287                                    libvlc_media_list_t * p_mlist,
288                                    libvlc_media_descriptor_t * p_md,
289                                    int index,
290                                    libvlc_exception_t * p_e )
291 {
292     (void)p_e;
293     libvlc_media_descriptor_retain( p_md );
294
295     ARRAY_INSERT( p_mlist->items, p_md, index);
296     notify_item_addition( p_mlist, p_md, index );
297 }
298
299 /**************************************************************************
300  *       libvlc_media_list_remove_index (Public)
301  *
302  * Lock should be hold when entering.
303  **************************************************************************/
304 void libvlc_media_list_remove_index( libvlc_media_list_t * p_mlist,
305                                      int index,
306                                      libvlc_exception_t * p_e )
307 {
308     libvlc_media_descriptor_t * p_md;
309
310     p_md = ARRAY_VAL( p_mlist->items, index );
311
312     ARRAY_REMOVE( p_mlist->items, index )
313     notify_item_deletion( p_mlist, p_md, index );
314
315     libvlc_media_descriptor_release( p_md );
316 }
317
318 /**************************************************************************
319  *       libvlc_media_list_item_at_index (Public)
320  *
321  * Lock should be hold when entering.
322  **************************************************************************/
323 libvlc_media_descriptor_t *
324 libvlc_media_list_item_at_index( libvlc_media_list_t * p_mlist,
325                                  int index,
326                                  libvlc_exception_t * p_e )
327 {
328     libvlc_media_descriptor_t * p_md =  ARRAY_VAL( p_mlist->items, index );
329     libvlc_media_descriptor_retain( p_md );
330     return p_md;
331 }
332
333 /**************************************************************************
334  *       libvlc_media_list_index_of_item (Public)
335  *
336  * Lock should be hold when entering.
337  * Warning: this function would return the first matching item
338  **************************************************************************/
339 int libvlc_media_list_index_of_item( libvlc_media_list_t * p_mlist,
340                                      libvlc_media_descriptor_t * p_searched_md,
341                                      libvlc_exception_t * p_e )
342 {
343     libvlc_media_descriptor_t * p_md;
344     FOREACH_ARRAY( p_md, p_mlist->items )
345         if( p_searched_md == p_md )
346             return fe_idx; /* Once more, we hate macro for that */
347     FOREACH_END()
348     return -1;
349 }
350
351 /**************************************************************************
352  *       libvlc_media_list_lock (Public)
353  *
354  * The lock must be held in access operations. It is never used in the
355  * Public method.
356  **************************************************************************/
357 void libvlc_media_list_lock( libvlc_media_list_t * p_mlist )
358 {
359     vlc_mutex_lock( &p_mlist->object_lock );
360 }
361
362
363 /**************************************************************************
364  *       libvlc_media_list_unlock (Public)
365  *
366  * The lock must be held in access operations
367  **************************************************************************/
368 void libvlc_media_list_unlock( libvlc_media_list_t * p_mlist )
369 {
370     vlc_mutex_unlock( &p_mlist->object_lock );
371 }
372
373
374
375 /**************************************************************************
376  *       libvlc_media_list_p_event_manager (Public)
377  *
378  * The p_event_manager is immutable, so you don't have to hold the lock
379  **************************************************************************/
380 libvlc_event_manager_t *
381 libvlc_media_list_event_manager( libvlc_media_list_t * p_mlist,
382                                     libvlc_exception_t * p_e )
383 {
384     (void)p_e;
385     return p_mlist->p_event_manager;
386 }