1 /*****************************************************************************
2 * media_list_player.c: libvlc new API media_list player functions
3 *****************************************************************************
4 * Copyright (C) 2007 the VideoLAN team
7 * Authors: Pierre d'Herbemont <pdherbemont # videolan.org>
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.
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.
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 *****************************************************************************/
24 #include <vlc/libvlc.h>
25 #include <vlc/libvlc_media.h>
26 #include <vlc/libvlc_media_list.h>
27 #include <vlc/libvlc_media_player.h>
28 #include <vlc/libvlc_media_list_player.h>
29 #include <vlc/libvlc_events.h>
32 #include "libvlc_internal.h"
34 #include "media_internal.h" // Abuse, could and should be removed
35 #include "media_list_path.h"
37 //#define DEBUG_MEDIA_LIST_PLAYER
39 /* This is a very dummy implementation of playlist on top of
40 * media_list and media_player.
42 * All this code is doing is simply computing the next item
43 * of a tree of media_list (see get_next_index()), and play
44 * the next item when the current is over. This is happening
45 * via the event callback media_player_reached_end().
47 * This is thread safe, and we use a two keys (locks) scheme
48 * to discriminate between callbacks and regular uses.
51 struct libvlc_media_list_player_t
53 libvlc_event_manager_t * p_event_manager;
54 libvlc_instance_t * p_libvlc_instance;
56 /* Protect access to this structure. */
57 vlc_mutex_t object_lock;
58 /* Protect access to this structure and from callback execution. */
59 vlc_mutex_t mp_callback_lock;
60 /* Indicate to media player callbacks that they are cancelled. */
61 bool are_mp_callback_cancelled;
62 libvlc_media_list_path_t current_playing_item_path;
63 libvlc_media_t * p_current_playing_item;
64 libvlc_media_list_t * p_mlist;
65 libvlc_media_player_t * p_mi;
68 /* This is not yet exported by libvlccore */
69 static inline void vlc_assert_locked(vlc_mutex_t *mutex)
78 static void next(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e);
79 static void stop(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e);
85 /**************************************************************************
87 **************************************************************************/
88 static inline void lock(libvlc_media_list_player_t * p_mlp)
90 // Obtain an access to this structure
91 vlc_mutex_lock(&p_mlp->object_lock);
93 // Make sure no callback will occurs at the same time
94 vlc_mutex_lock(&p_mlp->mp_callback_lock);
97 static inline void unlock(libvlc_media_list_player_t * p_mlp)
99 vlc_mutex_unlock(&p_mlp->mp_callback_lock);
100 vlc_mutex_unlock(&p_mlp->object_lock);
103 static inline void assert_locked(libvlc_media_list_player_t * p_mlp)
105 vlc_assert_locked(&p_mlp->mp_callback_lock);
108 static inline libvlc_event_manager_t * mlist_em(libvlc_media_list_player_t * p_mlp)
110 assert_locked(p_mlp);
111 return libvlc_media_list_event_manager(p_mlp->p_mlist, NULL);
114 static inline libvlc_event_manager_t * mplayer_em(libvlc_media_list_player_t * p_mlp)
116 assert_locked(p_mlp);
117 return libvlc_media_player_event_manager(p_mlp->p_mi, NULL);
121 /**************************************************************************
122 * get_next_path (private)
124 * Basic and dummy next item fetcher.
125 **************************************************************************/
126 static libvlc_media_list_path_t
127 get_next_path(libvlc_media_list_player_t * p_mlp)
129 assert_locked(p_mlp);
131 /* We are entered with libvlc_media_list_lock(p_mlp->p_list) */
132 libvlc_media_list_path_t ret;
133 libvlc_media_list_t * p_parent_of_playing_item;
134 libvlc_media_list_t * p_sublist_of_playing_item;
136 if (!p_mlp->current_playing_item_path)
138 if (!libvlc_media_list_count(p_mlp->p_mlist, NULL))
140 return libvlc_media_list_path_with_root_index(0);
143 p_sublist_of_playing_item = libvlc_media_list_sublist_at_path(
145 p_mlp->current_playing_item_path);
147 /* If item just gained a sublist just play it */
148 if (p_sublist_of_playing_item)
150 libvlc_media_list_release(p_sublist_of_playing_item);
151 return libvlc_media_list_path_copy_by_appending(p_mlp->current_playing_item_path, 0);
154 /* Try to catch next element */
155 p_parent_of_playing_item = libvlc_media_list_parentlist_at_path(p_mlp->p_mlist,
156 p_mlp->current_playing_item_path);
158 int depth = libvlc_media_list_path_depth(p_mlp->current_playing_item_path);
159 if (depth < 1 || !p_parent_of_playing_item)
162 ret = libvlc_media_list_path_copy(p_mlp->current_playing_item_path);
164 ret[depth-1]++; // Play next element
166 /* If this goes beyong the end of the list */
167 while(ret[depth-1] >= libvlc_media_list_count(p_parent_of_playing_item, NULL))
173 libvlc_media_list_release(p_parent_of_playing_item);
178 p_parent_of_playing_item = libvlc_media_list_parentlist_at_path(
182 libvlc_media_list_release(p_parent_of_playing_item);
186 /**************************************************************************
187 * media_player_reached_end (private) (Event Callback)
188 **************************************************************************/
190 media_player_reached_end(const libvlc_event_t * p_event, void * p_user_data)
193 libvlc_media_list_player_t * p_mlp = p_user_data;
194 libvlc_exception_t e;
195 libvlc_exception_init(&e);
197 vlc_mutex_lock(&p_mlp->mp_callback_lock);
198 if (!p_mlp->are_mp_callback_cancelled)
200 vlc_mutex_unlock(&p_mlp->mp_callback_lock);
202 // There is no point in reporting an error from this callback
203 libvlc_exception_clear(&e);
206 /**************************************************************************
207 * playlist_item_deleted (private) (Event Callback)
208 **************************************************************************/
210 mlist_item_deleted(const libvlc_event_t * p_event, void * p_user_data)
212 libvlc_media_list_player_t * p_mlp = p_user_data;
213 libvlc_media_list_t * p_emitting_mlist = p_event->p_obj;
214 libvlc_media_t * p_current_md = NULL;
217 if (p_mlp->current_playing_item_path)
218 p_current_md = libvlc_media_list_item_at_path(p_mlp->p_mlist, p_mlp->current_playing_item_path);
220 if (p_event->u.media_list_item_deleted.item == p_current_md &&
221 p_emitting_mlist == p_mlp->p_mlist)
223 /* We are playing this item, let's stop */
230 /**************************************************************************
231 * install_playlist_observer (private)
232 **************************************************************************/
234 install_playlist_observer(libvlc_media_list_player_t * p_mlp)
236 assert_locked(p_mlp);
237 libvlc_event_attach(mlist_em(p_mlp), libvlc_MediaListItemDeleted, mlist_item_deleted, p_mlp, NULL);
240 /**************************************************************************
241 * uninstall_playlist_observer (private)
242 **************************************************************************/
244 uninstall_playlist_observer(libvlc_media_list_player_t * p_mlp)
246 assert_locked(p_mlp);
247 if (!p_mlp->p_mlist) return;
248 libvlc_event_detach(mlist_em(p_mlp), libvlc_MediaListItemDeleted, mlist_item_deleted, p_mlp, NULL);
251 /**************************************************************************
252 * install_media_player_observer (private)
253 **************************************************************************/
255 install_media_player_observer(libvlc_media_list_player_t * p_mlp)
257 assert_locked(p_mlp);
258 libvlc_event_attach_async(mplayer_em(p_mlp), libvlc_MediaPlayerEndReached, media_player_reached_end, p_mlp, NULL);
262 /**************************************************************************
263 * uninstall_media_player_observer (private)
264 **************************************************************************/
266 uninstall_media_player_observer(libvlc_media_list_player_t * p_mlp)
268 assert_locked(p_mlp);
269 if (!p_mlp->p_mi) return;
271 // From now on, media_player callback won't be relevant.
272 p_mlp->are_mp_callback_cancelled = true;
274 // Allow callbacks to run, because detach() will wait until all callbacks are processed.
275 // This is safe because only callbacks are allowed, and there execution will be cancelled.
276 vlc_mutex_unlock(&p_mlp->mp_callback_lock);
277 libvlc_event_detach(mplayer_em(p_mlp), libvlc_MediaPlayerEndReached, media_player_reached_end, p_mlp, NULL);
279 // Now, lock back the callback lock. No more callback will be present from this point.
280 vlc_mutex_lock(&p_mlp->mp_callback_lock);
281 p_mlp->are_mp_callback_cancelled = false;
283 // What is here is safe, because we garantee that we won't be able to anything concurently,
284 // - except (cancelled) callbacks - thanks to the object_lock.
287 /**************************************************************************
288 * set_current_playing_item (private)
290 * Playlist lock should be held
291 **************************************************************************/
293 set_current_playing_item(libvlc_media_list_player_t * p_mlp, libvlc_media_list_path_t path)
295 assert_locked(p_mlp);
297 /* First, save the new path that we are going to play */
298 if (p_mlp->current_playing_item_path != path)
300 free(p_mlp->current_playing_item_path);
301 p_mlp->current_playing_item_path = path;
307 libvlc_media_t * p_md;
308 p_md = libvlc_media_list_item_at_path(p_mlp->p_mlist, path);
312 /* Make sure media_player_reached_end() won't get called */
313 uninstall_media_player_observer(p_mlp);
315 /* Create a new media_player if there is none */
317 p_mlp->p_mi = libvlc_media_player_new_from_media(p_md, NULL);
319 libvlc_media_player_set_media(p_mlp->p_mi, p_md, NULL);
321 install_media_player_observer(p_mlp);
322 libvlc_media_release(p_md); /* for libvlc_media_list_item_at_index */
326 * Public libvlc functions
329 /**************************************************************************
331 **************************************************************************/
332 libvlc_media_list_player_t *
333 libvlc_media_list_player_new(libvlc_instance_t * p_instance, libvlc_exception_t * p_e)
336 libvlc_media_list_player_t * p_mlp;
337 p_mlp = calloc(sizeof(libvlc_media_list_player_t), 1);
341 libvlc_retain(p_instance);
342 p_mlp->p_libvlc_instance = p_instance;
343 p_mlp->i_refcount = 1;
344 vlc_mutex_init(&p_mlp->object_lock);
345 vlc_mutex_init(&p_mlp->mp_callback_lock);
346 p_mlp->p_event_manager = libvlc_event_manager_new(p_mlp, p_instance, p_e);
347 libvlc_event_manager_register_event_type(p_mlp->p_event_manager, libvlc_MediaListPlayerNextItemSet, p_e);
352 /**************************************************************************
354 **************************************************************************/
355 void libvlc_media_list_player_release(libvlc_media_list_player_t * p_mlp)
362 if (p_mlp->i_refcount > 0)
368 assert(p_mlp->i_refcount == 0);
370 /* Keep the lock(), because the uninstall functions
371 * check for it. That's convenient. */
375 uninstall_media_player_observer(p_mlp);
376 libvlc_media_player_release(p_mlp->p_mi);
380 uninstall_playlist_observer(p_mlp);
381 libvlc_media_list_release(p_mlp->p_mlist);
385 vlc_mutex_destroy(&p_mlp->object_lock);
386 vlc_mutex_destroy(&p_mlp->mp_callback_lock);
388 libvlc_event_manager_release(p_mlp->p_event_manager);
390 free(p_mlp->current_playing_item_path);
391 libvlc_release(p_mlp->p_libvlc_instance);
395 /**************************************************************************
396 * event_manager (Public)
397 **************************************************************************/
398 libvlc_event_manager_t *
399 libvlc_media_list_player_event_manager(libvlc_media_list_player_t * p_mlp)
401 return p_mlp->p_event_manager;
404 /**************************************************************************
405 * set_media_player (Public)
406 **************************************************************************/
407 void libvlc_media_list_player_set_media_player(libvlc_media_list_player_t * p_mlp, libvlc_media_player_t * p_mi, libvlc_exception_t * p_e)
415 uninstall_media_player_observer(p_mlp);
416 libvlc_media_player_release(p_mlp->p_mi);
418 libvlc_media_player_retain(p_mi);
421 install_media_player_observer(p_mlp);
426 /**************************************************************************
427 * set_media_list (Public)
428 **************************************************************************/
429 void libvlc_media_list_player_set_media_list(libvlc_media_list_player_t * p_mlp, libvlc_media_list_t * p_mlist, libvlc_exception_t * p_e)
435 libvlc_exception_raise(p_e, "No media list provided");
441 uninstall_playlist_observer(p_mlp);
442 libvlc_media_list_release(p_mlp->p_mlist);
444 libvlc_media_list_retain(p_mlist);
445 p_mlp->p_mlist = p_mlist;
447 install_playlist_observer(p_mlp);
452 /**************************************************************************
454 **************************************************************************/
455 void libvlc_media_list_player_play(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
457 if (!p_mlp->current_playing_item_path)
459 libvlc_media_list_player_next(p_mlp, p_e);
460 return; /* Will set to play */
463 libvlc_media_player_play(p_mlp->p_mi, p_e);
467 /**************************************************************************
469 **************************************************************************/
470 void libvlc_media_list_player_pause(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
474 libvlc_media_player_pause(p_mlp->p_mi, p_e);
477 /**************************************************************************
478 * is_playing (Public)
479 **************************************************************************/
481 libvlc_media_list_player_is_playing(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
483 libvlc_state_t state = libvlc_media_player_get_state(p_mlp->p_mi, p_e);
484 return (state == libvlc_Opening) || (state == libvlc_Buffering) ||
485 (state == libvlc_Playing);
488 /**************************************************************************
490 **************************************************************************/
492 libvlc_media_list_player_get_state(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
496 return libvlc_media_player_get_state(p_mlp->p_mi, p_e);
499 /**************************************************************************
500 * Play item at index (Public)
501 **************************************************************************/
502 void libvlc_media_list_player_play_item_at_index(libvlc_media_list_player_t * p_mlp, int i_index, libvlc_exception_t * p_e)
507 set_current_playing_item(p_mlp, libvlc_media_list_path_with_root_index(i_index));
508 libvlc_media_player_play(p_mlp->p_mi, p_e);
511 /* Send the next item event */
512 libvlc_event_t event;
513 event.type = libvlc_MediaListPlayerNextItemSet;
514 libvlc_event_send(p_mlp->p_event_manager, &event);
517 /**************************************************************************
519 **************************************************************************/
520 void libvlc_media_list_player_play_item(libvlc_media_list_player_t * p_mlp, libvlc_media_t * p_md, libvlc_exception_t * p_e)
523 libvlc_media_list_path_t path = libvlc_media_list_path_of_item(p_mlp->p_mlist, p_md);
526 libvlc_exception_raise(p_e, "No such item in media list");
531 set_current_playing_item(p_mlp, path);
532 libvlc_media_player_play(p_mlp->p_mi, p_e);
536 /**************************************************************************
540 **************************************************************************/
541 static void stop(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
543 assert_locked(p_mlp);
545 if (p_mlp->p_mi && p_mlp->current_playing_item_path)
547 /* We are not interested in getting media stop event now */
548 uninstall_media_player_observer(p_mlp);
549 libvlc_media_player_stop(p_mlp->p_mi, p_e);
550 install_media_player_observer(p_mlp);
553 free(p_mlp->current_playing_item_path);
554 p_mlp->current_playing_item_path = NULL;
557 /**************************************************************************
559 **************************************************************************/
560 void libvlc_media_list_player_stop(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
567 /**************************************************************************
571 **************************************************************************/
572 static void next(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)
574 assert_locked(p_mlp);
578 libvlc_exception_raise(p_e, "No media list");
582 libvlc_media_list_lock(p_mlp->p_mlist);
584 libvlc_media_list_path_t path = get_next_path(p_mlp);
586 #ifdef DEBUG_MEDIA_LIST_PLAYER
588 libvlc_media_list_path_dump(path);
591 set_current_playing_item(p_mlp, path);
595 libvlc_media_list_unlock(p_mlp->p_mlist);
600 libvlc_media_player_play(p_mlp->p_mi, p_e);
602 libvlc_media_list_unlock(p_mlp->p_mlist);
604 /* Send the next item event */
605 libvlc_event_t event;
606 event.type = libvlc_MediaListPlayerNextItemSet;
607 libvlc_media_t * p_md = libvlc_media_list_item_at_path(p_mlp->p_mlist, path);
608 event.u.media_list_player_next_item_set.item = p_md;
609 libvlc_event_send(p_mlp->p_event_manager, &event);
610 libvlc_media_release(p_md);
613 /**************************************************************************
615 **************************************************************************/
616 void libvlc_media_list_player_next(libvlc_media_list_player_t * p_mlp, libvlc_exception_t * p_e)