1 /*****************************************************************************
2 * media_list.c: libvlc new API media list functions
3 *****************************************************************************
4 * Copyright (C) 2007 VLC authors and VideoLAN
7 * Authors: Pierre d'Herbemont <pdherbemont # videolan.org>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Lesser General Public License as published by
11 * the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
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 Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
30 #include <vlc/libvlc.h>
31 #include <vlc/libvlc_media.h>
32 #include <vlc/libvlc_media_list.h>
33 #include <vlc/libvlc_events.h>
35 #include <vlc_common.h>
36 #include <vlc_input.h>
38 #include "libvlc_internal.h"
39 #include "media_internal.h" // libvlc_media_new_from_input_item()
40 #include "media_list_internal.h"
42 typedef enum EventPlaceInTime
{
53 /**************************************************************************
54 * notify_item_addition (private)
56 * Do the appropriate action when an item is deleted.
57 **************************************************************************/
59 notify_item_addition( libvlc_media_list_t
* p_mlist
,
60 libvlc_media_t
* p_md
,
62 EventPlaceInTime event_status
)
66 /* Construct the event */
67 if( event_status
== EventDidHappen
)
69 event
.type
= libvlc_MediaListItemAdded
;
70 event
.u
.media_list_item_added
.item
= p_md
;
71 event
.u
.media_list_item_added
.index
= index
;
73 else /* if( event_status == EventWillHappen ) */
75 event
.type
= libvlc_MediaListWillAddItem
;
76 event
.u
.media_list_will_add_item
.item
= p_md
;
77 event
.u
.media_list_will_add_item
.index
= index
;
81 libvlc_event_send( p_mlist
->p_event_manager
, &event
);
84 /**************************************************************************
85 * notify_item_deletion (private)
87 * Do the appropriate action when an item is added.
88 **************************************************************************/
90 notify_item_deletion( libvlc_media_list_t
* p_mlist
,
91 libvlc_media_t
* p_md
,
93 EventPlaceInTime event_status
)
97 /* Construct the event */
98 if( event_status
== EventDidHappen
)
100 event
.type
= libvlc_MediaListItemDeleted
;
101 event
.u
.media_list_item_deleted
.item
= p_md
;
102 event
.u
.media_list_item_deleted
.index
= index
;
104 else /* if( event_status == EventWillHappen ) */
106 event
.type
= libvlc_MediaListWillDeleteItem
;
107 event
.u
.media_list_will_delete_item
.item
= p_md
;
108 event
.u
.media_list_will_delete_item
.index
= index
;
112 libvlc_event_send( p_mlist
->p_event_manager
, &event
);
115 /* LibVLC internal */
116 void libvlc_media_list_internal_end_reached( libvlc_media_list_t
* p_mlist
)
118 libvlc_event_t event
;
120 event
.type
= libvlc_MediaListEndReached
;
123 libvlc_event_send( p_mlist
->p_event_manager
, &event
);
126 /**************************************************************************
127 * static mlist_is_writable (private)
128 **************************************************************************/
130 bool mlist_is_writable( libvlc_media_list_t
*p_mlist
)
132 if( !p_mlist
||p_mlist
->b_read_only
)
134 /* We are read-only from user side */
135 libvlc_printerr( "Attempt to write a read-only media list" );
142 * Public libvlc functions
145 /**************************************************************************
146 * libvlc_media_list_new (Public)
149 **************************************************************************/
150 libvlc_media_list_t
*
151 libvlc_media_list_new( libvlc_instance_t
* p_inst
)
153 libvlc_media_list_t
* p_mlist
;
155 p_mlist
= malloc(sizeof(libvlc_media_list_t
));
156 if( unlikely(p_mlist
== NULL
) )
158 libvlc_printerr( "Not enough memory" );
162 p_mlist
->p_libvlc_instance
= p_inst
;
163 p_mlist
->p_event_manager
= libvlc_event_manager_new( p_mlist
);
164 if( unlikely(p_mlist
->p_event_manager
== NULL
) )
170 p_mlist
->b_read_only
= false;
172 vlc_mutex_init( &p_mlist
->object_lock
);
173 vlc_mutex_init( &p_mlist
->refcount_lock
); // FIXME: spinlock?
175 vlc_array_init( &p_mlist
->items
);
176 assert( p_mlist
->items
.i_count
== 0 );
177 p_mlist
->i_refcount
= 1;
178 p_mlist
->p_md
= NULL
;
179 p_mlist
->p_internal_md
= NULL
;
181 libvlc_retain( p_inst
);
185 /**************************************************************************
186 * libvlc_media_list_release (Public)
189 **************************************************************************/
190 void libvlc_media_list_release( libvlc_media_list_t
* p_mlist
)
192 libvlc_media_t
* p_md
;
195 vlc_mutex_lock( &p_mlist
->refcount_lock
);
196 p_mlist
->i_refcount
--;
197 if( p_mlist
->i_refcount
> 0 )
199 vlc_mutex_unlock( &p_mlist
->refcount_lock
);
202 vlc_mutex_unlock( &p_mlist
->refcount_lock
);
204 /* Refcount null, time to free */
206 libvlc_event_manager_release( p_mlist
->p_event_manager
);
208 libvlc_media_release( p_mlist
->p_md
);
210 for ( i
= 0; i
< vlc_array_count( &p_mlist
->items
); i
++ )
212 p_md
= vlc_array_item_at_index( &p_mlist
->items
, i
);
213 libvlc_media_release( p_md
);
216 vlc_mutex_destroy( &p_mlist
->object_lock
);
217 vlc_mutex_destroy( &p_mlist
->refcount_lock
);
218 vlc_array_clear( &p_mlist
->items
);
220 libvlc_release( p_mlist
->p_libvlc_instance
);
224 /**************************************************************************
225 * libvlc_media_list_retain (Public)
227 * Increase an object refcount.
228 **************************************************************************/
229 void libvlc_media_list_retain( libvlc_media_list_t
* p_mlist
)
231 vlc_mutex_lock( &p_mlist
->refcount_lock
);
232 p_mlist
->i_refcount
++;
233 vlc_mutex_unlock( &p_mlist
->refcount_lock
);
237 /**************************************************************************
238 * add_file_content (Public)
239 **************************************************************************/
241 libvlc_media_list_add_file_content( libvlc_media_list_t
* p_mlist
,
242 const char * psz_uri
)
244 input_item_t
* p_input_item
;
245 libvlc_media_t
* p_md
;
247 p_input_item
= input_item_NewExt( psz_uri
,
248 _("Media Library"), 0, NULL
, 0, -1 );
252 libvlc_printerr( "Not enough memory" );
256 p_md
= libvlc_media_new_from_input_item( p_mlist
->p_libvlc_instance
,
260 vlc_gc_decref( p_input_item
);
264 if( libvlc_media_list_add_media( p_mlist
, p_md
) )
266 #warning Missing error handling!
267 /* printerr and leaks */
271 input_Read( p_mlist
->p_libvlc_instance
->p_libvlc_int
, p_input_item
);
275 /**************************************************************************
277 **************************************************************************/
278 void libvlc_media_list_set_media( libvlc_media_list_t
* p_mlist
,
279 libvlc_media_t
* p_md
)
282 vlc_mutex_lock( &p_mlist
->object_lock
);
283 if( p_mlist
->p_internal_md
|| !mlist_is_writable(p_mlist
) )
285 vlc_mutex_unlock( &p_mlist
->object_lock
);
288 libvlc_media_release( p_mlist
->p_md
);
289 libvlc_media_retain( p_md
);
290 p_mlist
->p_md
= p_md
;
291 vlc_mutex_unlock( &p_mlist
->object_lock
);
294 /**************************************************************************
297 * If this media_list comes is a media's subitems,
298 * This holds the corresponding media.
299 * This md is also seen as the information holder for the media_list.
300 * Indeed a media_list can have meta information through this
302 **************************************************************************/
304 libvlc_media_list_media( libvlc_media_list_t
* p_mlist
)
306 libvlc_media_t
*p_md
;
308 vlc_mutex_lock( &p_mlist
->object_lock
);
309 p_md
= p_mlist
->p_internal_md
? p_mlist
->p_internal_md
: p_mlist
->p_md
;
311 libvlc_media_retain( p_md
);
312 vlc_mutex_unlock( &p_mlist
->object_lock
);
317 /**************************************************************************
318 * libvlc_media_list_count (Public)
320 * Lock should be held when entering.
321 **************************************************************************/
322 int libvlc_media_list_count( libvlc_media_list_t
* p_mlist
)
324 return vlc_array_count( &p_mlist
->items
);
327 /**************************************************************************
328 * libvlc_media_list_add_media (Public)
330 * Lock should be held when entering.
331 **************************************************************************/
332 int libvlc_media_list_add_media( libvlc_media_list_t
* p_mlist
,
333 libvlc_media_t
* p_md
)
335 if( !mlist_is_writable(p_mlist
) )
337 libvlc_media_list_internal_add_media( p_mlist
, p_md
);
341 /* LibVLC internal version */
342 void libvlc_media_list_internal_add_media( libvlc_media_list_t
* p_mlist
,
343 libvlc_media_t
* p_md
)
345 libvlc_media_retain( p_md
);
347 notify_item_addition( p_mlist
, p_md
, vlc_array_count( &p_mlist
->items
),
349 vlc_array_append( &p_mlist
->items
, p_md
);
350 notify_item_addition( p_mlist
, p_md
, vlc_array_count( &p_mlist
->items
)-1,
354 /**************************************************************************
355 * libvlc_media_list_insert_media (Public)
357 * Lock should be hold when entering.
358 **************************************************************************/
359 int libvlc_media_list_insert_media( libvlc_media_list_t
* p_mlist
,
360 libvlc_media_t
* p_md
,
363 if( !mlist_is_writable(p_mlist
) )
365 libvlc_media_list_internal_insert_media( p_mlist
, p_md
, index
);
369 /* LibVLC internal version */
370 void libvlc_media_list_internal_insert_media( libvlc_media_list_t
* p_mlist
,
371 libvlc_media_t
* p_md
,
374 libvlc_media_retain( p_md
);
376 notify_item_addition( p_mlist
, p_md
, index
, EventWillHappen
);
377 vlc_array_insert( &p_mlist
->items
, p_md
, index
);
378 notify_item_addition( p_mlist
, p_md
, index
, EventDidHappen
);
381 /**************************************************************************
382 * libvlc_media_list_remove_index (Public)
384 * Lock should be held when entering.
385 **************************************************************************/
386 int libvlc_media_list_remove_index( libvlc_media_list_t
* p_mlist
,
389 if( !mlist_is_writable(p_mlist
) )
391 return libvlc_media_list_internal_remove_index( p_mlist
, index
);
394 /* LibVLC internal version */
395 int libvlc_media_list_internal_remove_index( libvlc_media_list_t
* p_mlist
,
398 libvlc_media_t
* p_md
;
400 if( index
< 0 || index
>= vlc_array_count( &p_mlist
->items
))
402 libvlc_printerr( "Index out of bounds" );
406 p_md
= vlc_array_item_at_index( &p_mlist
->items
, index
);
408 notify_item_deletion( p_mlist
, p_md
, index
, EventWillHappen
);
409 vlc_array_remove( &p_mlist
->items
, index
);
410 notify_item_deletion( p_mlist
, p_md
, index
, EventDidHappen
);
412 libvlc_media_release( p_md
);
416 /**************************************************************************
417 * libvlc_media_list_item_at_index (Public)
419 * Lock should be held when entering.
420 **************************************************************************/
422 libvlc_media_list_item_at_index( libvlc_media_list_t
* p_mlist
,
425 libvlc_media_t
* p_md
;
427 if( index
< 0 || index
>= vlc_array_count( &p_mlist
->items
))
429 libvlc_printerr( "Index out of bounds" );
433 p_md
= vlc_array_item_at_index( &p_mlist
->items
, index
);
434 libvlc_media_retain( p_md
);
438 /**************************************************************************
439 * libvlc_media_list_index_of_item (Public)
441 * Lock should be held when entering.
442 * Warning: this function returns the first matching item.
443 **************************************************************************/
444 int libvlc_media_list_index_of_item( libvlc_media_list_t
* p_mlist
,
445 libvlc_media_t
* p_searched_md
)
447 libvlc_media_t
* p_md
;
449 for ( i
= 0; i
< vlc_array_count( &p_mlist
->items
); i
++ )
451 p_md
= vlc_array_item_at_index( &p_mlist
->items
, i
);
452 if( p_searched_md
== p_md
)
455 libvlc_printerr( "Media not found" );
459 /**************************************************************************
460 * libvlc_media_list_is_readonly (Public)
462 * This indicates if this media list is read-only from a user point of view
463 **************************************************************************/
464 int libvlc_media_list_is_readonly( libvlc_media_list_t
* p_mlist
)
466 return p_mlist
->b_read_only
;
469 /**************************************************************************
470 * libvlc_media_list_lock (Public)
472 * The lock must be held in access operations. It is never used in the
474 **************************************************************************/
475 void libvlc_media_list_lock( libvlc_media_list_t
* p_mlist
)
477 vlc_mutex_lock( &p_mlist
->object_lock
);
481 /**************************************************************************
482 * libvlc_media_list_unlock (Public)
484 * The lock must be held in access operations
485 **************************************************************************/
486 void libvlc_media_list_unlock( libvlc_media_list_t
* p_mlist
)
488 vlc_mutex_unlock( &p_mlist
->object_lock
);
492 /**************************************************************************
493 * libvlc_media_list_p_event_manager (Public)
495 * The p_event_manager is immutable, so you don't have to hold the lock
496 **************************************************************************/
497 libvlc_event_manager_t
*
498 libvlc_media_list_event_manager( libvlc_media_list_t
* p_mlist
)
500 return p_mlist
->p_event_manager
;