VLC  4.0.0-dev
vlc_player.h
Go to the documentation of this file.
1 /*****************************************************************************
2  * vlc_player.h: player interface
3  *****************************************************************************
4  * Copyright (C) 2018 VLC authors and VideoLAN
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as published by
8  * the Free Software Foundation; either version 2.1 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
19  *****************************************************************************/
20 
21 #ifndef VLC_PLAYER_H
22 #define VLC_PLAYER_H 1
23 
24 #include <vlc_input.h>
25 #include <vlc_aout.h>
26 
27 /**
28  * @defgroup vlc_player Player
29  * @ingroup input
30  * VLC Player API
31  * @brief
32 @dot
33 digraph player_states {
34  label="Player state diagram";
35  new [style="invis"];
36  started [label="Started" URL="@ref VLC_PLAYER_STATE_STARTED"];
37  playing [label="Playing" URL="@ref VLC_PLAYER_STATE_PLAYING"];
38  paused [label="Paused" URL="@ref VLC_PLAYER_STATE_PAUSED"];
39  stopping [label="Stopping" URL="@ref VLC_PLAYER_STATE_STOPPING"];
40  stopped [label="Stopped" URL="@ref VLC_PLAYER_STATE_STOPPED"];
41  new -> stopped [label="vlc_player_New()" URL="@ref vlc_player_New" fontcolor="green3"];
42  started -> playing [style="dashed" label=<<i>internal transition</i>>];
43  started -> stopping [label="vlc_player_Stop()" URL="@ref vlc_player_Stop" fontcolor="red"];
44  playing -> paused [label="vlc_player_Pause()" URL="@ref vlc_player_Pause" fontcolor="blue"];
45  paused -> playing [label="vlc_player_Resume()" URL="@ref vlc_player_Resume" fontcolor="blue3"];
46  paused -> stopping [label="vlc_player_Stop()" URL="@ref vlc_player_Stop" fontcolor="red"];
47  playing -> stopping [label="vlc_player_Stop()" URL="@ref vlc_player_Stop" fontcolor="red"];
48  stopping -> stopped [style="dashed" label=<<i>internal transition</i>>];
49  stopped -> started [label="vlc_player_Start()" URL="@ref vlc_player_Start" fontcolor="darkgreen"];
50 }
51 @enddot
52  * @{
53  * @file
54  * VLC Player API
55  */
56 
57 /**
58  * @defgroup vlc_player__instance Player instance
59  * @{
60  */
61 
62 /**
63  * Player opaque structure.
64  */
65 typedef struct vlc_player_t vlc_player_t;
66 
67 /**
68  * Player lock type (normal or reentrant)
69  */
71 {
72  /**
73  * Normal lock
74  *
75  * If the player is already locked, subsequent calls to vlc_player_Lock()
76  * will deadlock.
77  */
79 
80  /**
81  * Reentrant lock
82  *
83  * If the player is already locked, subsequent calls to vlc_player_Lock()
84  * will still succeed. To unlock the player, one call to
85  * vlc_player_Unlock() per vlc_player_Lock() is necessary.
86  */
88 };
89 
90 /**
91  * Action when the player is stopped
92  *
93  * @see vlc_player_SetMediaStoppedAction()
94  */
96  /** Continue (or stop if there is no next media), default behavior */
98  /** Pause when reaching the end of file */
100  /** Stop, even if there is a next media to play */
102  /** Exit VLC */
104 };
105 
106 /**
107  * Callbacks for the owner of the player.
108  *
109  * These callbacks are needed to control the player flow (via the
110  * vlc_playlist_t as a owner for example). It can only be set when creating the
111  * player via vlc_player_New().
112  *
113  * All callbacks are called with the player locked (cf. vlc_player_Lock()), and
114  * from any thread (even the current one).
115  */
117 {
118  /**
119  * Called when the player requires a new media
120  *
121  * @note The returned media must be already held with input_item_Hold()
122  *
123  * @param player locked player instance
124  * @param data opaque pointer set from vlc_player_New()
125  * @return the next media to play, held by the callee with input_item_Hold()
126  */
127  input_item_t *(*get_next)(vlc_player_t *player, void *data);
128 };
129 
130 /**
131  * Create a new player instance
132  *
133  * @param parent parent VLC object
134  * @param media_provider pointer to a media_provider structure or NULL, the
135  * structure must be valid during the lifetime of the player
136  * @param media_provider_data opaque data used by provider callbacks
137  * @return a pointer to a valid player instance or NULL in case of error
138  */
140 vlc_player_New(vlc_object_t *parent, enum vlc_player_lock_type lock_type,
141  const struct vlc_player_media_provider *media_provider,
142  void *media_provider_data);
143 
144 /**
145  * Delete a player instance
146  *
147  * This function stop any playback previously started and wait for their
148  * termination.
149  *
150  * @warning Blocking function if the player state is not STOPPED, don't call it
151  * from an UI thread in that case.
152  *
153  * @param player unlocked player instance created by vlc_player_New()
154  */
155 VLC_API void
157 
158 /**
159  * Lock the player.
160  *
161  * All player functions (except vlc_player_Delete()) need to be called while
162  * the player lock is held.
163  *
164  * @param player unlocked player instance
165  */
166 VLC_API void
168 
169 /**
170  * Unlock the player
171  *
172  * @param player locked player instance
173  */
174 VLC_API void
176 
177 /**
178  * Wait on a condition variable
179  *
180  * This call allow users to use their own condition with the player mutex.
181  *
182  * @param player locked player instance
183  * @param cond external condition
184  */
185 VLC_API void
187 
188 /**
189  * Setup an action when a media is stopped
190  *
191  * @param player locked player instance
192  * @param action action to do when a media is stopped
193  */
194 VLC_API void
196  enum vlc_player_media_stopped_action action);
197 
198 /**
199  * Ask to start in a paused state
200  *
201  * This function can be used before vlc_player_Start()
202  *
203  * @param player locked player instance
204  * @param start_paused true to start in a paused state, false to cancel it
205  */
206 VLC_API void
207 vlc_player_SetStartPaused(vlc_player_t *player, bool start_paused);
208 
209 /**
210  * Enable or disable pause on cork event
211  *
212  * If enabled, the player will automatically pause and resume on cork events.
213  * In that case, cork events won't be propagated via callbacks.
214  * @see vlc_player_cbs.on_cork_changed
215  *
216  * @param player locked player instance
217  * @param enabled true to enable
218  */
219 VLC_API void
220 vlc_player_SetPauseOnCork(vlc_player_t *player, bool enabled);
221 
222 /** @} vlc_player__instance */
223 
224 /**
225  * @defgroup vlc_player__playback Playback control
226  * @{
227  */
228 
229 /**
230  * State of the player
231  *
232  * During a normal playback (no errors), the user is expected to receive all
233  * events in the following order: STARTED, PLAYING, STOPPING, STOPPED.
234  *
235  * @note When playing more than one media in a row, the player stay at the
236  * PLAYING state when doing the transition from the current media to the next
237  * media (that can be gapless). This means that STOPPING, STOPPED states (for
238  * the current media) and STARTED, PLAYING states (for the next one) won't be
239  * sent. Nevertheless, the vlc_player_cbs.on_current_media_changed callback
240  * will be called during this transition.
241  */
242 enum vlc_player_state
243 {
244  /**
245  * The player is stopped
246  *
247  * Initial state, or triggered by an internal transition from the STOPPING
248  * state.
249  */
252  /**
253  * The player is started
254  *
255  * Triggered by vlc_player_Start()
256  */
259  /**
260  * The player is playing
261  *
262  * Triggered by vlc_player_Resume() or by an internal transition from the
263  * STARTED state.
264  */
267  /**
268  * The player is paused
269  *
270  * Triggered by vlc_player_Pause().
271  */
274  /**
275  * The player is stopping
276  *
277  * Triggered by vlc_player_Stop(), vlc_player_SetCurrentMedia() or by an
278  * internal transition (when the media reach the end of file for example).
279  */
281 };
282 
283 /**
284  * Error of the player
285  *
286  * @see vlc_player_GetError()
287  */
288 enum vlc_player_error
289 {
292 };
293 
294 /**
295  * Seek speed type
296  *
297  * @see vlc_player_SeekByPos()
298  * @see vlc_player_SeekByTime()
299  */
301 {
302  /** Do a precise seek */
304  /** Do a fast seek */
306 };
307 
308 /**
309  * Player seek/delay directive
310  *
311  * @see vlc_player_SeekByPos()
312  * @see vlc_player_SeekByTime()
313  * @see vlc_player_SetCategoryDelay()
314  */
316 {
317  /** Given time/position */
319  /** The current position +/- the given time/position */
321 };
322 
323 /**
324  * Menu (VCD/DVD/BD) and viewpoint navigations
325  *
326  * @see vlc_player_Navigate()
327  */
328 enum vlc_player_nav
329 {
330  /** Activate the navigation item selected */
332  /** Select a navigation item above or move the viewpoint up */
334  /** Select a navigation item under or move the viewpoint down */
336  /** Select a navigation item on the left or move the viewpoint left */
338  /** Select a navigation item on the right or move the viewpoint right */
340  /** Activate the popup Menu (for BD) */
342  /** Activate disc Root Menu */
344 };
345 
346 /**
347  * A to B loop state
348  */
350 {
354 };
355 
356 /** Player capability: can seek */
357 #define VLC_PLAYER_CAP_SEEK (1<<0)
358 /** Player capability: can pause */
359 #define VLC_PLAYER_CAP_PAUSE (1<<1)
360 /** Player capability: can change the rate */
361 #define VLC_PLAYER_CAP_CHANGE_RATE (1<<2)
362 /** Player capability: can seek back */
363 #define VLC_PLAYER_CAP_REWIND (1<<3)
365 /** Player teletext key: Red */
366 #define VLC_PLAYER_TELETEXT_KEY_RED ('r' << 16)
367 /** Player teletext key: Green */
368 #define VLC_PLAYER_TELETEXT_KEY_GREEN ('g' << 16)
369 /** Player teletext key: Yellow */
370 #define VLC_PLAYER_TELETEXT_KEY_YELLOW ('y' << 16)
371 /** Player teletext key: Blue */
372 #define VLC_PLAYER_TELETEXT_KEY_BLUE ('b' << 16)
373 /** Player teletext key: Index */
374 #define VLC_PLAYER_TELETEXT_KEY_INDEX ('i' << 16)
377 {
381 };
382 
383 /**
384  * Set the current media
385  *
386  * This function replaces the current and next medias.
387  *
388  * @note A successful call will always result of
389  * vlc_player_cbs.on_current_media_changed being called. This function is not
390  * blocking. If a media is currently being played, this media will be stopped
391  * and the requested media will be set after.
392  *
393  * @warning This function is either synchronous (if the player state is
394  * STOPPED) or asynchronous. In the later case, vlc_player_GetCurrentMedia()
395  * will return the old media, even after this call, and until the
396  * vlc_player_cbs.on_current_media_changed is called.
397  *
398  * @param player locked player instance
399  * @param media new media to play (will be held by the player)
400  * @return VLC_SUCCESS or a VLC error code
401  */
402 VLC_API int
404 
405 /**
406  * Get the current played media.
407  *
408  * @see vlc_player_cbs.on_current_media_changed
409  *
410  * @param player locked player instance
411  * @return a valid media or NULL (if no media is set)
412  */
415 
416 /**
417  * Helper that hold the current media
418  */
419 static inline input_item_t *
421 {
423  return item ? input_item_Hold(item) : NULL;
424 }
425 
426 /**
427  * Invalidate the next media.
428  *
429  * This function can be used to invalidate the media returned by the
430  * vlc_player_media_provider.get_next callback. This can be used when the next
431  * item from a playlist was changed by the user.
432  *
433  * Calling this function will trigger the
434  * vlc_player_media_provider.get_next callback to be called again.
435  *
436  * @param player locked player instance
437  */
438 VLC_API void
440 
441 /**
442  * Start the playback of the current media.
443  *
444  * @param player locked player instance
445  * @return VLC_SUCCESS or a VLC error code
446  */
447 VLC_API int
449 
450 /**
451  * Stop the playback of the current media
452  *
453  * @note This function is asynchronous. In case of success, the user should wait
454  * for the STOPPED state event to know when the stop is finished.
455  *
456  * @param player locked player instance
457  * @return VLC_SUCCESS if the player is being stopped, VLC_EGENERIC otherwise
458  * (no-op)
459  */
460 VLC_API int
462 
463 /**
464  * Pause the playback
465  *
466  * @param player locked player instance
467  */
468 VLC_API void
470 
471 /**
472  * Resume the playback from a pause
473  *
474  * @param player locked player instance
475  */
476 VLC_API void
478 
479 /**
480  * Pause and display the next video frame
481  *
482  * @param player locked player instance
483  */
484 VLC_API void
486 
487 /**
488  * Get the state of the player
489  *
490  * @note Since all players actions are asynchronous, this function won't
491  * reflect the new state immediately. Wait for the
492  * vlc_players_cbs.on_state_changed event to be notified.
493  *
494  * @see vlc_player_state
495  * @see vlc_player_cbs.on_state_changed
496  *
497  * @param player locked player instance
498  * @return the current player state
499  */
502 
503 /**
504  * Get the error state of the player
505  *
506  * @see vlc_player_cbs.on_capabilities_changed
507  *
508  * @param player locked player instance
509  * @return the current error state
510  */
513 
514 /**
515  * Helper to get the started state
516  */
517 static inline bool
519 {
520  switch (vlc_player_GetState(player))
521  {
525  return true;
526  default:
527  return false;
528  }
529 }
530 
531 /**
532  * Helper to get the paused state
533  */
534 static inline bool
536 {
538 }
539 
540 /**
541  * Helper to toggle the pause state
542  */
543 static inline void
545 {
546  if (vlc_player_IsStarted(player))
547  {
548  if (vlc_player_IsPaused(player))
549  vlc_player_Resume(player);
550  else
551  vlc_player_Pause(player);
552  }
553 }
554 
555 /**
556  * Get the player capabilities
557  *
558  * @see vlc_player_cbs.on_capabilities_changed
559  *
560  * @param player locked player instance
561  * @return the player capabilities, a bitwise mask of @ref VLC_PLAYER_CAP_SEEK,
562  * @ref VLC_PLAYER_CAP_PAUSE, @ref VLC_PLAYER_CAP_CHANGE_RATE, @ref
563  * VLC_PLAYER_CAP_REWIND
564  */
565 VLC_API int
567 
568 /**
569  * Helper to get the seek capability
570  */
571 static inline bool
573 {
575 }
576 
577 /**
578  * Helper to get the pause capability
579  */
580 static inline bool
582 {
584 }
585 
586 /**
587  * Helper to get the change-rate capability
588  */
589 static inline bool
591 {
593 }
594 
595 /**
596  * Helper to get the rewindable capability
597  */
598 static inline bool
600 {
602 }
603 
604 /**
605  * Get the rate of the player
606  *
607  * @see vlc_player_cbs.on_rate_changed
608  *
609  * @param player locked player instance
610  * @return rate of the player (< 1.f is slower, > 1.f is faster)
611  */
612 VLC_API float
614 
615 /**
616  * Change the rate of the player
617  *
618  * @note The rate is saved across several medias
619  *
620  * @param player locked player instance
621  * @param rate new rate (< 1.f is slower, > 1.f is faster)
622  */
623 VLC_API void
624 vlc_player_ChangeRate(vlc_player_t *player, float rate);
625 
626 /**
627  * Increment the rate of the player (faster)
628  *
629  * @param player locked player instance
630  */
631 VLC_API void
633 
634 /**
635  * Decrement the rate of the player (Slower)
636  *
637  * @param player locked player instance
638  */
639 VLC_API void
641 
642 /**
643  * Get the length of the current media
644  *
645  * @note A started and playing media doesn't have necessarily a valid length.
646  *
647  * @see vlc_player_cbs.on_length_changed
648  *
649  * @param player locked player instance
650  * @return a valid length or VLC_TICK_INVALID (if no media is set,
651  * playback is not yet started or in case of error)
652  */
655 
656 /**
657  * Get the time of the current media
658  *
659  * @note A started and playing media doesn't have necessarily a valid time.
660  *
661  * @see vlc_player_cbs.on_position_changed
662  *
663  * @param player locked player instance
664  * @return a valid time or VLC_TICK_INVALID (if no media is set, the media
665  * doesn't have any time, if playback is not yet started or in case of error)
666  */
669 
670 /**
671  * Get the position of the current media
672  *
673  * @see vlc_player_cbs.on_position_changed
674  *
675  * @param player locked player instance
676  * @return a valid position in the range [0.f;1.f] or -1.f (if no media is
677  * set,if playback is not yet started or in case of error)
678  */
679 VLC_API float
681 
682 /**
683  * Seek the current media by position
684  *
685  * @note This function can be called before vlc_player_Start() in order to set
686  * a starting position.
687  *
688  * @param player locked player instance
689  * @param position position in the range [0.f;1.f]
690  * @param speed precise of fast
691  * @param whence absolute or relative
692  */
693 VLC_API void
694 vlc_player_SeekByPos(vlc_player_t *player, float position,
695  enum vlc_player_seek_speed speed,
696  enum vlc_player_whence whence);
697 
698 /**
699  * Seek the current media by time
700  *
701  * @note This function can be called before vlc_player_Start() in order to set
702  * a starting position.
703  *
704  * @warning This function has an effect only if the media has a valid length.
705  *
706  * @param player locked player instance
707  * @param time a time in the range [0;length]
708  * @param speed precise of fast
709  * @param whence absolute or relative
710  */
711 VLC_API void
713  enum vlc_player_seek_speed speed,
714  enum vlc_player_whence whence);
715 
716 /**
717  * Helper to set the absolute position precisely
718  */
719 static inline void
720 vlc_player_SetPosition(vlc_player_t *player, float position)
721 {
724 }
725 
726 /**
727  * Helper to set the absolute position fast
728  */
729 static inline void
730 vlc_player_SetPositionFast(vlc_player_t *player, float position)
731 {
732  vlc_player_SeekByPos(player, position, VLC_PLAYER_SEEK_FAST,
734 }
735 
736 /**
737  * Helper to jump the position precisely
738  */
739 static inline void
740 vlc_player_JumpPos(vlc_player_t *player, float jumppos)
741 {
742  /* No fask seek for jumps. Indeed, jumps can seek to the current position
743  * if not precise enough or if the jump value is too small. */
746 }
747 
748 /**
749  * Helper to set the absolute time precisely
750  */
751 static inline void
753 {
756 }
757 
758 /**
759  * Helper to set the absolute time fast
760  */
761 static inline void
763 {
766 }
767 
768 /**
769  * Helper to jump the time precisely
770  */
771 static inline void
773 {
774  /* No fask seek for jumps. Indeed, jumps can seek to the current position
775  * if not precise enough or if the jump value is too small. */
778 }
779 
780 /**
781  * Display the player position on the vout OSD
782  *
783  * @param player locked player instance
784  */
785 VLC_API void
787 
788 /**
789  * Enable A to B loop of the current media
790  *
791  * This function need to be called 2 times with VLC_PLAYER_ABLOOP_A and
792  * VLC_PLAYER_ABLOOP_B to setup an A to B loop. It current the current
793  * time/position when called. The B time must be higher than the A time.
794  *
795  * @param player locked player instance
796  * @return VLC_SUCCESS or a VLC error code
797  */
798 VLC_API int
800 
801 /**
802  * Get the A to B loop status
803  *
804  * @note If the returned status is VLC_PLAYER_ABLOOP_A, then a_time and a_pos
805  * will be valid. If the returned status is VLC_PLAYER_ABLOOP_B, then all
806  * output parameters are valid. If the returned status is
807  * VLC_PLAYER_ABLOOP_NONE, then all output parameters are invalid.
808  *
809  * @see vlc_player_cbs.on_atobloop_changed
810  *
811  * @param player locked player instance
812  * @param a_time A time or VLC_TICK_INVALID (if the media doesn't have valid
813  * times)
814  * @param a_pos A position
815  * @param b_time B time or VLC_TICK_INVALID (if the media doesn't have valid
816  * times)
817  * @param b_pos B position
818  * @return A to B loop status
819  */
821 vlc_player_GetAtoBLoop(vlc_player_t *player, vlc_tick_t *a_time, float *a_pos,
822  vlc_tick_t *b_time, float *b_pos);
823 
824 /**
825  * Navigate (for DVD/Bluray menus or viewpoint)
826  *
827  * @param player locked player instance
828  * @param nav navigation key
829  */
830 VLC_API void
832 
833 /**
834  * Update the viewpoint
835  *
836  * @param player locked player instance
837  * @param viewpoint the viewpoint value
838  * @param whence absolute or relative
839  * @return VLC_SUCCESS or a VLC error code
840  */
841 VLC_API void
843  const vlc_viewpoint_t *viewpoint,
844  enum vlc_player_whence whence);
845 
846 /**
847  * Check if the playing is recording
848  *
849  * @see vlc_player_cbs.on_recording_changed
850  *
851  * @param player locked player instance
852  * @return true if the player is recording
853  */
854 VLC_API bool
856 
857 /**
858  * Enable or disable recording for the current media
859  *
860  * @note A successful call will trigger the vlc_player_cbs.on_recording_changed
861  * event.
862  *
863  * @param player locked player instance
864  * @param enabled true to enable recording
865  */
866 VLC_API void
867 vlc_player_SetRecordingEnabled(vlc_player_t *player, bool enabled);
868 
869 /**
870  * Helper to toggle the recording state
871  */
872 static inline void
874 {
876 }
877 
878 /**
879  * Add an associated (or external) media to the current media
880  *
881  * @param player locked player instance
882  * @param cat AUDIO_ES or SPU_ES
883  * @param uri absolute uri of the external media
884  * @param select true to select the track of this external media
885  * @param notify true to notify the OSD
886  * @param check_ext true to check subtitles extension
887  */
888 VLC_API int
890  enum es_format_category_e cat, const char *uri,
891  bool select, bool notify, bool check_ext);
892 
893 /**
894  * Get the signal quality and strength of the current media
895  *
896  * @param player locked player instance
897  */
898 VLC_API int
899 vlc_player_GetSignal(vlc_player_t *player, float *quality, float *strength);
900 
901 /**
902  * Get the statistics of the current media
903  *
904  * @warning The returned pointer becomes invalid when the player is unlocked.
905  * The referenced structure can be safely copied.
906  *
907  * @see vlc_player_cbs.on_statistics_changed
908  *
909  * @param player locked player instance
910  * @return pointer to the player stats structure or NULL
911  */
912 VLC_API const struct input_stats_t *
914 
915 /**
916  * Restore the previous playback position of the current media
917  */
918 VLC_API void
920 
921 /**
922  * Get the V4L2 object used to do controls
923  *
924  * @param player locked player instance
925  * @return the V4L2 object or NULL if not any. This object must be used with
926  * the player lock held.
927  */
930 
931 /** @} vlc_player__playback */
932 
933 /**
934  * @defgroup vlc_player__titles Title and chapter control
935  * @{
936  */
937 
938 /**
939  * Player chapter structure
940  */
941 struct vlc_player_chapter
942 {
943  /** Chapter name, always valid */
944  const char *name;
945  /** Position of this chapter */
946  vlc_tick_t time;
947 };
948 
949 /** vlc_player_title.flags: The title is a menu. */
950 #define VLC_PLAYER_TITLE_MENU 0x01
951 /** vlc_player_title.flags: The title is interactive. */
952 #define VLC_PLAYER_TITLE_INTERACTIVE 0x02
954 /** Player title structure */
955 struct vlc_player_title
956 {
957  /** Title name, always valid */
958  const char *name;
959  /** Length of the title */
960  vlc_tick_t length;
961  /** Bit flag of @ref VLC_PLAYER_TITLE_MENU and @ref
962  * VLC_PLAYER_TITLE_INTERACTIVE */
963  unsigned flags;
964  /** Number of chapters, can be 0 */
965  size_t chapter_count;
966  /** Array of chapters, can be NULL */
967  const struct vlc_player_chapter *chapters;
968 };
969 
970 /**
971  * Opaque structure representing a list of @ref vlc_player_title.
972  *
973  * @see vlc_player_GetTitleList()
974  * @see vlc_player_title_list_GetCount()
975  * @see vlc_player_title_list_GetAt()
976  */
979 /**
980  * Hold the title list of the player
981  *
982  * This function can be used to pass this title list from a callback to an
983  * other thread.
984  *
985  * @see vlc_player_cbs.on_titles_changed
986  *
987  * @return the same instance
988  */
991 
992 /**
993  * Release of previously held title list
994  */
995 VLC_API void
997 
998 /**
999  * Get the number of title of a list
1000  */
1001 VLC_API size_t
1003 
1004 /**
1005  * Get the title at a given index
1006  *
1007  * @param idx index in the range [0; count[
1008  * @return a valid title (can't be NULL)
1009  */
1010 VLC_API const struct vlc_player_title *
1012 
1013 /**
1014  * Get the title list of the current media
1015  *
1016  * @see vlc_player_cbs.on_titles_changed
1017  *
1018  * @param player locked player instance
1019  */
1022 
1023 /**
1024  * Get the selected title index for the current media
1025  *
1026  * @see vlc_player_cbs.on_title_selection_changed
1027  *
1028  * @param player locked player instance
1029  */
1030 VLC_API ssize_t
1032 
1033 /**
1034  * Helper to get the current selected title
1035  */
1036 static inline const struct vlc_player_title *
1040  if (!titles)
1041  return NULL;
1042  ssize_t selected_idx = vlc_player_GetSelectedTitleIdx(player);
1043  if (selected_idx < 0)
1044  return NULL;
1045  return vlc_player_title_list_GetAt(titles, selected_idx);
1046 }
1047 
1048 /**
1049  * Select a title index for the current media
1050  *
1051  * @note A successful call will trigger the
1052  * vlc_player_cbs.on_title_selection_changed event.
1053  *
1054  * @see vlc_player_title_list_GetAt()
1055  * @see vlc_player_title_list_GetCount()
1056  *
1057  * @param player locked player instance
1058  * @param index valid index in the range [0;count[
1059  */
1060 VLC_API void
1061 vlc_player_SelectTitleIdx(vlc_player_t *player, size_t index);
1062 
1063 /**
1064  * Select a title for the current media
1065  *
1066  * @note A successful call will trigger the
1067  * vlc_player_cbs.on_title_selection_changed event.
1068  *
1069  * @see vlc_player_title_list_GetAt()
1070  * @see vlc_player_title_list_GetCount()
1071  *
1072  * @param player locked player instance
1073  * @param title a valid title coming from the vlc_player_title_list
1074  */
1075 VLC_API void
1077  const struct vlc_player_title *title);
1078 
1079 /**
1080  * Select a chapter for the current media
1081  *
1082  * @note A successful call will trigger the
1083  * vlc_player_cbs.on_chapter_selection_changed event.
1084  *
1085  * @param player locked player instance
1086  * @param title the selected title
1087  * @param chapter_idx index from vlc_player_title.chapters
1088  */
1089 VLC_API void
1091  const struct vlc_player_title *title,
1092  size_t chapter_idx);
1093 
1094 /**
1095  * Select the next title for the current media
1096  *
1097  * @see vlc_player_SelectTitleIdx()
1098  */
1099 VLC_API void
1101 
1102 /**
1103  * Select the previous title for the current media
1104  *
1105  * @see vlc_player_SelectTitleIdx()
1106  */
1107 VLC_API void
1109 
1110 /**
1111  * Get the selected chapter index for the current media
1112  *
1113  * @see vlc_player_cbs.on_chapter_selection_changed
1114  *
1115  * @param player locked player instance
1116  */
1117 VLC_API ssize_t
1119 
1120 /**
1121  * Helper to get the current selected chapter
1122  */
1123 static inline const struct vlc_player_chapter *
1126  const struct vlc_player_title *title = vlc_player_GetSelectedTitle(player);
1127  if (!title || !title->chapter_count)
1128  return NULL;
1129  ssize_t chapter_idx = vlc_player_GetSelectedChapterIdx(player);
1130  return chapter_idx >= 0 ? &title->chapters[chapter_idx] : NULL;
1131 }
1132 
1133 /**
1134  * Select a chapter index for the current media
1135  *
1136  * @note A successful call will trigger the
1137  * vlc_player_cbs.on_chaper_selection_changed event.
1138  *
1139  * @see vlc_player_title.chapters
1140  *
1141  * @param player locked player instance
1142  * @param index valid index in the range [0;vlc_player_title.chapter_count[
1143  */
1144 VLC_API void
1145 vlc_player_SelectChapterIdx(vlc_player_t *player, size_t index);
1146 
1147 /**
1148  * Select the next chapter for the current media
1149  *
1150  * @see vlc_player_SelectChapterIdx()
1151  */
1152 VLC_API void
1154 
1155 /**
1156  * Select the previous chapter for the current media
1157  *
1158  * @see vlc_player_SelectChapterIdx()
1159  */
1160 VLC_API void
1162 
1163 /** @} vlc_player__titles */
1164 
1165 /**
1166  * @defgroup vlc_player__programs Program control
1167  * @{
1168  */
1169 
1170 /**
1171  * Player program structure.
1172  */
1173 struct vlc_player_program
1175  /** Id used for vlc_player_SelectProgram() */
1176  int group_id;
1177  /** Program name, always valid */
1178  const char *name;
1179  /** True if the program is selected */
1180  bool selected;
1181  /** True if the program is scrambled */
1182  bool scrambled;
1183 };
1184 
1185 /**
1186  * Duplicate a program
1187  *
1188  * This function can be used to pass a program from a callback to an other
1189  * context.
1190  *
1191  * @see vlc_player_cbs.on_program_list_changed
1192  *
1193  * @return a duplicated program or NULL on allocation error
1194  */
1195 VLC_API struct vlc_player_program *
1196 vlc_player_program_Dup(const struct vlc_player_program *prgm);
1197 
1198 /**
1199  * Delete a duplicated program
1200  */
1201 VLC_API void
1203 
1204 /**
1205  * Get the number of programs
1206  *
1207  * @warning The returned size becomes invalid when the player is unlocked.
1208  *
1209  * @param player locked player instance
1210  * @return number of programs, or 0 (in case of error, or if the media is not
1211  * started)
1212  */
1213 VLC_API size_t
1215 
1216 /**
1217  * Get the program at a specific index
1218  *
1219  * @warning The behaviour is undefined if the index is not valid.
1220  *
1221  * @warning The returned pointer becomes invalid when the player is unlocked.
1222  * The referenced structure can be safely copied with vlc_player_program_Dup().
1223  *
1224  * @param player locked player instance
1225  * @param index valid index in the range [0; count[
1226  * @return a valid program (can't be NULL if vlc_player_GetProgramCount()
1227  * returned a valid count)
1228  */
1229 VLC_API const struct vlc_player_program *
1230 vlc_player_GetProgramAt(vlc_player_t *player, size_t index);
1231 
1232 /**
1233  * Get a program from an ES group identifier
1234  *
1235  * @param player locked player instance
1236  * @param group_id a program ID (retrieved from
1237  * vlc_player_cbs.on_program_list_changed or vlc_player_GetProgramAt())
1238  * @return a valid program or NULL (if the program was terminated by the
1239  * playback thread)
1240  */
1241 VLC_API const struct vlc_player_program *
1243 
1244 /**
1245  * Select a program from an ES group identifier
1246  *
1247  * @param player locked player instance
1248  * @param group_id a program ID (retrieved from
1249  * vlc_player_cbs.on_program_list_changed or vlc_player_GetProgramAt())
1250  */
1251 VLC_API void
1253 
1254 /**
1255  * Select the next program
1256  *
1257  * @param player locked player instance
1258  */
1259 VLC_API void
1261 
1262 /**
1263  * Select the previous program
1264  *
1265  * @param player locked player instance
1266  */
1267 VLC_API void
1269 
1270 /**
1271  * Helper to get the current selected program
1272  */
1273 static inline const struct vlc_player_program *
1276  size_t count = vlc_player_GetProgramCount(player);
1277  for (size_t i = 0; i < count; ++i)
1278  {
1279  const struct vlc_player_program *program =
1280  vlc_player_GetProgramAt(player, i);
1281  assert(program);
1282  if (program->selected)
1283  return program;
1284  }
1285  return NULL;
1286 }
1287 
1288 /** @} vlc_player__programs */
1289 
1290 /**
1291  * @defgroup vlc_player__tracks Tracks control
1292  * @{
1293  */
1294 
1295 /**
1296  * Player selection policy
1297  *
1298  * @see vlc_player_SelectEsId()
1299  */
1302  /**
1303  * Only one track per category is selected. Selecting a track with this
1304  * policy will disable all other tracks for the same category.
1305  */
1307  /**
1308  * Select multiple tracks for one category.
1309  *
1310  * Only one audio track can be selected at a time.
1311  * Two subtitle tracks can be selected simultaneously.
1312  * Multiple video tracks can be selected simultaneously.
1313  */
1315 };
1316 
1317 /**
1318  * Player track structure.
1319  *
1320  * A track is a representation of an ES identifier at a given time. Once the
1321  * player is unlocked, all content except the es_id pointer can be updated.
1322  *
1323  * @see vlc_player_cbs.on_track_list_changed
1324  * @see vlc_player_GetTrack
1325  */
1326 struct vlc_player_track
1328  /** Id used for any player actions, like vlc_player_SelectEsId() */
1329  vlc_es_id_t *es_id;
1330  /** Track name, always valid */
1331  const char *name;
1332  /** Es format */
1333  es_format_t fmt;
1334  /** True if the track is selected */
1335  bool selected;
1336 };
1337 
1338 /**
1339  * Duplicate a track
1340  *
1341  * This function can be used to pass a track from a callback to an other
1342  * context. The es_id will be held by the duplicated track.
1343  *
1344  * @warning The returned track won't be updated if the original one is modified
1345  * by the player.
1346  *
1347  * @see vlc_player_cbs.on_track_list_changed
1348  *
1349  * @return a duplicated track or NULL on allocation error
1350  */
1351 VLC_API struct vlc_player_track *
1352 vlc_player_track_Dup(const struct vlc_player_track *track);
1353 
1354 /**
1355  * Delete a duplicated track
1356  */
1357 VLC_API void
1359 
1360 /**
1361  * Get the number of tracks for an ES category
1362  *
1363  * @warning The returned size becomes invalid when the player is unlocked.
1364  *
1365  * @param player locked player instance
1366  * @param cat VIDEO_ES, AUDIO_ES or SPU_ES
1367  * @return number of tracks, or 0 (in case of error, or if the media is not
1368  * started)
1369  */
1370 VLC_API size_t
1372 
1373 /**
1374  * Get the track at a specific index for an ES category
1375  *
1376  * @warning The behaviour is undefined if the index is not valid.
1377  *
1378  * @warning The returned pointer becomes invalid when the player is unlocked.
1379  * The referenced structure can be safely copied with vlc_player_track_Dup().
1380  *
1381  * @param player locked player instance
1382  * @param cat VIDEO_ES, AUDIO_ES or SPU_ES
1383  * @param index valid index in the range [0; count[
1384  * @return a valid track (can't be NULL if vlc_player_GetTrackCount() returned
1385  * a valid count)
1386  */
1387 VLC_API const struct vlc_player_track *
1389  size_t index);
1390 
1391 /**
1392  * Helper to get the video track count
1393  */
1394 static inline size_t
1397  return vlc_player_GetTrackCount(player, VIDEO_ES);
1398 }
1399 
1400 /**
1401  * Helper to get a video track at a specific index
1402  */
1403 static inline const struct vlc_player_track *
1404 vlc_player_GetVideoTrackAt(vlc_player_t *player, size_t index)
1406  return vlc_player_GetTrackAt(player, VIDEO_ES, index);
1407 }
1408 
1409 /**
1410  * Helper to get the audio track count
1411  */
1412 static inline size_t
1415  return vlc_player_GetTrackCount(player, AUDIO_ES);
1416 }
1417 
1418 /**
1419  * Helper to get an audio track at a specific index
1420  */
1421 static inline const struct vlc_player_track *
1422 vlc_player_GetAudioTrackAt(vlc_player_t *player, size_t index)
1424  return vlc_player_GetTrackAt(player, AUDIO_ES, index);
1425 }
1426 
1427 /**
1428  * Helper to get the subtitle track count
1429  */
1430 static inline size_t
1433  return vlc_player_GetTrackCount(player, SPU_ES);
1434 }
1435 
1436 /**
1437  * Helper to get a subtitle track at a specific index
1438  */
1439 static inline const struct vlc_player_track *
1440 vlc_player_GetSubtitleTrackAt(vlc_player_t *player, size_t index)
1442  return vlc_player_GetTrackAt(player, SPU_ES, index);
1443 }
1444 
1445 /**
1446  * Get a track from an ES identifier
1447  *
1448  * @warning The returned pointer becomes invalid when the player is unlocked.
1449  * The referenced structure can be safely copied with vlc_player_track_Dup().
1450  *
1451  * @param player locked player instance
1452  * @param id an ES ID (retrieved from vlc_player_cbs.on_track_list_changed or
1453  * vlc_player_GetTrackAt())
1454  * @return a valid player track or NULL (if the track was terminated by the
1455  * playback thread)
1456  */
1457 VLC_API const struct vlc_player_track *
1459 
1460 /**
1461  * Get and the video output used by a ES identifier
1462  *
1463  * @warning A same vout can be associated with multiple ES during the lifetime
1464  * of the player. The information returned by this function becomes invalid
1465  * when the player is unlocked. The returned vout doesn't need to be released,
1466  * but must be held with vout_Hold() if it is accessed after the player is
1467  * unlocked.
1468  *
1469  * @param player locked player instance
1470  * @param id an ES ID (retrieved from vlc_player_cbs.on_track_list_changed or
1471  * vlc_player_GetTrackAt())
1472  * @param order if not null, the order of the vout
1473  * @return a valid vout or NULL (if the track is disabled, it it's not a video
1474  * or spu track, or if the vout failed to start)
1475  */
1478  enum vlc_vout_order *order);
1479 
1480 /**
1481  * Get the ES identifier of a video output
1482  *
1483  * @warning A same vout can be associated with multiple ES during the lifetime
1484  * of the player. The information returned by this function becomes invalid
1485  * when the player is unlocked. The returned es_id doesn't need to be released,
1486  * but must be held with vlc_es_id_Hold() if it accessed after the player is
1487  * unlocked.
1488  *
1489  * @param player locked player instance
1490  * @param vout vout (can't be NULL)
1491  * @return a valid ES identifier or NULL (if the vout is stopped)
1492  */
1495 
1496 /**
1497  * Helper to get the selected track from an ES category
1498  *
1499  * @warning The player can have more than one selected track for a same ES
1500  * category. This function will only return the first selected one. Use
1501  * vlc_player_GetTrackAt() and vlc_player_GetTrackCount() to iterate through
1502  * several selected tracks.
1503  */
1504 static inline const struct vlc_player_track *
1507  size_t count = vlc_player_GetTrackCount(player, cat);
1508  for (size_t i = 0; i < count; ++i)
1509  {
1510  const struct vlc_player_track *track =
1511  vlc_player_GetTrackAt(player, cat, i);
1512  assert(track);
1513  if (track->selected)
1514  return track;
1515  }
1516  return NULL;
1517 }
1518 
1519 /**
1520  * Select tracks by their string identifier
1521  *
1522  * This function can be used pre-select a list of tracks before starting the
1523  * player. It has only effect for the current media. It can also be used when
1524  * the player is already started.
1525 
1526  * 'str_ids' can contain more than one track id, delimited with ','. "" or any
1527  * invalid track id will cause the player to unselect all tracks of that
1528  * category. NULL will disable the preference for newer tracks without
1529  * unselecting any current tracks.
1530  *
1531  * Example:
1532  * - (VIDEO_ES, "video/1,video/2") will select these 2 video tracks. If there
1533  * is only one video track with the id "video/0", no tracks will be selected.
1534  * - (SPU_ES, "${slave_url_md5sum}/spu/0) will select one spu added by an input
1535  * slave with the corresponding url.
1536  *
1537  * @note The string identifier of a track can be found via vlc_es_id_GetStrId().
1538  *
1539  * @param player locked player instance
1540  * @param cat VIDEO_ES, AUDIO_ES or SPU_ES
1541  * @param str_ids list of string identifier or NULL
1542  */
1543 VLC_API void
1545  enum es_format_category_e cat,
1546  const char *str_ids);
1547 
1548 /**
1549  * Select a track from an ES identifier
1550  *
1551  * @note A successful call will trigger the
1552  * vlc_player_cbs.on_track_selection_changed event.
1553  *
1554  * @param player locked player instance
1555  * @param id an ES ID (retrieved from vlc_player_cbs.on_track_list_changed or
1556  * vlc_player_GetTrackAt())
1557  * @param policy exclusive or simultaneous
1558  * @return the number of track selected for es_id category
1559  */
1560 VLC_API unsigned
1562  enum vlc_player_select_policy policy);
1563 
1564 
1565 /**
1566  * Helper to select a track
1567  */
1568 static inline unsigned
1570  const struct vlc_player_track *track,
1571  enum vlc_player_select_policy policy)
1572 {
1573  return vlc_player_SelectEsId(player, track->es_id, policy);
1574 }
1575 
1576 /**
1577  * Select multiple tracks from a list of ES identifiers.
1578  *
1579  * Any tracks of the category, not referenced in the list will be unselected.
1580  *
1581  * @warning there is no guarantee all requested tracks will be selected. The
1582  * behaviour is undefined if the list is not null-terminated.
1583  *
1584  * @note A successful call will trigger the
1585  * vlc_player_cbs.on_track_selection_changed event for each track that has
1586  * its selection state changed.
1587  *
1588  * @see VLC_PLAYER_SELECT_SIMULTANEOUS
1589  *
1590  * @param player locked player instance
1591  * @param cat VIDEO_ES, AUDIO_ES or SPU_ES
1592  * @param es_id_list a null-terminated list of ES identifiers. es_ids not
1593  * corresponding to the category will be ignored.
1594  * (ES IDs can be retrieved from vlc_player_cbs.on_track_list_changed or
1595  * vlc_player_GetTrackAt())
1596  * @return the number of track selected for that category
1597  */
1598 VLC_API unsigned
1600  enum es_format_category_e cat,
1601  vlc_es_id_t *const es_id_list[]);
1602 
1603 /**
1604  * Select the next track
1605  *
1606  * If the last track is already selected, a call to this function will disable
1607  * this last track. And a second call will select the first track.
1608  *
1609  * @warning This function has no effects if there are several tracks selected
1610  * for a same category. Therefore the default policy is
1611  * VLC_PLAYER_SELECT_EXCLUSIVE.
1612  *
1613  * @param player locked player instance
1614  * @param cat VIDEO_ES, AUDIO_ES or SPU_ES
1615  */
1616 VLC_API void
1618  enum es_format_category_e cat);
1619 
1620 /**
1621  * Select the Previous track
1622  *
1623  * If the first track is already selected, a call to this function will disable
1624  * this first track. And a second call will select the last track.
1625  *
1626  * @warning This function has no effects if there are several tracks selected
1627  * for a same category. Therefore the default policy is
1628  * VLC_PLAYER_SELECT_EXCLUSIVE.
1629  *
1630  * @param player locked player instance
1631  * @param cat VIDEO_ES, AUDIO_ES or SPU_ES
1632  */
1633 VLC_API void
1635  enum es_format_category_e cat);
1636 
1637 /**
1638  * Unselect a track from an ES identifier
1639  *
1640  * @warning Other tracks of the same category won't be touched.
1641  *
1642  * @note A successful call will trigger the
1643  * vlc_player_cbs.on_track_selection_changed event.
1644  *
1645  * @param player locked player instance
1646  * @param id an ES ID (retrieved from vlc_player_cbs.on_track_list_changed or
1647  * vlc_player_GetTrackAt())
1648  */
1649 VLC_API void
1651 
1652 /**
1653  * Helper to unselect a track
1654  */
1655 static inline void
1657  const struct vlc_player_track *track)
1658 {
1659  vlc_player_UnselectEsId(player, track->es_id);
1660 }
1661 
1662 /**
1663  * Helper to unselect all tracks from an ES category
1664  */
1665 static inline void
1668 {
1669  size_t count = vlc_player_GetTrackCount(player, cat);
1670  for (size_t i = 0; i < count; ++i)
1671  {
1672  const struct vlc_player_track *track =
1673  vlc_player_GetTrackAt(player, cat, i);
1674  assert(track);
1675  if (track->selected)
1676  vlc_player_UnselectTrack(player, track);
1677  }
1678 }
1679 
1680 /**
1681  * Restart a track from an ES identifier
1682  *
1683  * @note A successful call will trigger the
1684  * vlc_player_cbs.on_track_selection_changed event.
1685  *
1686  * @param player locked player instance
1687  * @param id an ES ID (retrieved from vlc_player_cbs.on_track_list_changed or
1688  * vlc_player_GetTrackAt())
1689  */
1690 VLC_API void
1692 
1693 /**
1694  * Helper to restart a track
1695  */
1696 static inline void
1698  const struct vlc_player_track *track)
1699 {
1700  vlc_player_RestartEsId(player, track->es_id);
1701 }
1702 
1703 /**
1704  * Helper to restart all selected tracks from an ES category
1705  */
1706 static inline void
1709 {
1710  size_t count = vlc_player_GetTrackCount(player, cat);
1711  for (size_t i = 0; i < count; ++i)
1712  {
1713  const struct vlc_player_track *track =
1714  vlc_player_GetTrackAt(player, cat, i);
1715  assert(track);
1716  if (track->selected)
1717  vlc_player_RestartTrack(player, track);
1718  }
1719 }
1720 
1721 /**
1722  * Select the language for an ES category
1723  *
1724  * @warning The language will only be set for all future played media.
1725  *
1726  * @param player locked player instance
1727  * @param cat AUDIO_ES or SPU_ES
1728  * @param lang comma separated, two or three letters country code, 'any' as a
1729  * fallback or NULL to reset the default state
1730  */
1731 VLC_API void
1733  enum es_format_category_e cat,
1734  const char *lang);
1735 
1736 /**
1737  * Get the language of an ES category
1738  *
1739  * @warning This only reflects the change made by
1740  * vlc_player_SelectCategoryLanguage(). The current playing track doesn't
1741  * necessarily correspond to the returned language.
1742  *
1743  * @see vlc_player_SelectCategoryLanguage
1744  *
1745  * @param player locked player instance
1746  * @param cat AUDIO_ES or SPU_ES
1747  * @return valid language or NULL, need to be freed
1748  */
1749 VLC_API char *
1751  enum es_format_category_e cat);
1752 
1753 /**
1754  * Helper to select the audio language
1755  */
1756 static inline void
1757 vlc_player_SelectAudioLanguage(vlc_player_t *player, const char *lang)
1760 }
1761 
1762 /**
1763  * Helper to select the subtitle language
1764  */
1765 static inline void
1766 vlc_player_SelectSubtitleLanguage(vlc_player_t *player, const char *lang)
1769 }
1770 
1771 /**
1772  * Enable or disable a track category
1773  *
1774  * If a track category is disabled, the player won't select any tracks of this
1775  * category automatically or via an user action (vlc_player_SelectTrack()).
1776  *
1777  * @param player locked player instance
1778  * @param cat VIDEO_ES, AUDIO_ES or SPU_ES
1779  * @param enabled true to enable
1780  */
1781 VLC_API void
1783  enum es_format_category_e cat, bool enabled);
1784 
1785 /**
1786  * Check if a track category is enabled
1787  *
1788  * @param player locked player instance
1789  * @param cat VIDEO_ES, AUDIO_ES or SPU_ES
1790  */
1791 VLC_API bool
1793  enum es_format_category_e cat);
1794 
1795 /**
1796  * Helper to enable or disable video tracks
1797  */
1798 static inline void
1799 vlc_player_SetVideoEnabled(vlc_player_t *player, bool enabled)
1801  vlc_player_SetTrackCategoryEnabled(player, VIDEO_ES, enabled);
1802 }
1803 
1804 /**
1805  * Helper to check if video tracks are enabled
1806  */
1807 static inline bool
1811 }
1812 
1813 /**
1814  * Helper to enable or disable audio tracks
1815  */
1816 static inline void
1817 vlc_player_SetAudioEnabled(vlc_player_t *player, bool enabled)
1819  vlc_player_SetTrackCategoryEnabled(player, AUDIO_ES, enabled);
1820 }
1821 
1822 /**
1823  * Helper to check if audio tracks are enabled
1824  */
1825 static inline bool
1829 }
1830 
1831 /**
1832  * Helper to enable or disable subtitle tracks
1833  */
1834 static inline void
1835 vlc_player_SetSubtitleEnabled(vlc_player_t *player, bool enabled)
1837  vlc_player_SetTrackCategoryEnabled(player, SPU_ES, enabled);
1838 }
1839 
1840 /**
1841  * Helper to check if subtitle tracks are enabled
1842  */
1843 static inline bool
1846  return vlc_player_IsTrackCategoryEnabled(player, SPU_ES);
1847 }
1848 
1849 /**
1850  * Helper to toggle subtitles
1851  */
1852 static inline void
1855  bool enabled = !vlc_player_IsSubtitleEnabled(player);
1856  return vlc_player_SetSubtitleEnabled(player, enabled);
1857 }
1858 
1859 /**
1860  * Set the subtitle text scaling factor
1861  *
1862  * @note This function have an effect only if the subtitle track is a text type.
1863  *
1864  * @param player locked player instance
1865  * @param scale factor in the range [10;500] (default: 100)
1866  */
1867 VLC_API void
1868 vlc_player_SetSubtitleTextScale(vlc_player_t *player, unsigned scale);
1869 
1870 /**
1871  * Get the subtitle text scaling factor
1872  *
1873  * @param player locked player instance
1874  * @return scale factor
1875  */
1876 VLC_API unsigned
1878 
1879 /** @} vlc_player__tracks */
1880 
1881 /**
1882  * @defgroup vlc_player__tracks_sync Tracks synchronisation (delay)
1883  * @{
1884  */
1885 
1886 /**
1887  * Get the delay of an ES category for the current media
1888  *
1889  * @see vlc_player_cbs.on_category_delay_changed
1890  *
1891  * @param player locked player instance
1892  * @param cat AUDIO_ES or SPU_ES (VIDEO_ES not supported yet)
1893  * @return a valid delay or 0
1894  */
1897 
1898 /**
1899  * Set the delay of one category for the current media
1900  *
1901  * @note A successful call will trigger the
1902  * vlc_player_cbs.on_category_delay_changed event.
1903  *
1904  * @warning This has no effect on tracks where the delay was set by
1905  * vlc_player_SetEsIdDelay()
1906  *
1907  * @param player locked player instance
1908  * @param cat AUDIO_ES or SPU_ES (VIDEO_ES not supported yet)
1909  * @param delay a valid time
1910  * @param whence absolute or relative
1911  * @return VLC_SUCCESS or VLC_EGENERIC if the category is not handled
1912  */
1913 VLC_API int
1915  vlc_tick_t delay, enum vlc_player_whence whence);
1916 
1917 /**
1918  * Get the delay of a track
1919  *
1920  * @see vlc_player_cbs.on_track_delay_changed
1921  *
1922  * @param player locked player instance
1923  * @param id an ES ID (retrieved from vlc_player_cbs.on_track_list_changed or
1924  * vlc_player_GetTrackAt())
1925  * @return a valid delay or INT64_MAX is no delay is set for this track
1926  */
1929 
1930 /**
1931  * Set the delay of one track
1932  *
1933  * @note A successful call will trigger the
1934  * vlc_player_cbs.on_track_delay_changed event.
1935  *
1936  * @warning Setting the delay of one specific track will override previous and
1937  * future changes of delay made by vlc_player_SetCategoryDelay()
1938  *
1939  * @param player locked player instance
1940  * @param id an ES ID (retrieved from vlc_player_cbs.on_track_list_changed or
1941  * vlc_player_GetTrackAt())
1942  * @param delay a valid time or INT64_MAX to use default category delay
1943  * @param whence absolute or relative
1944  * @return VLC_SUCCESS or VLC_EGENERIC if the category of the es_id is not
1945  * handled (VIDEO_ES not supported yet)
1946  */
1947 VLC_API int
1949  vlc_tick_t delay, enum vlc_player_whence whence);
1950 
1951 /**
1952  * Helper to get the audio delay
1953  */
1954 static inline vlc_tick_t
1957  return vlc_player_GetCategoryDelay(player, AUDIO_ES);
1958 }
1959 
1960 /**
1961  * Helper to set the audio delay
1962  */
1963 static inline void
1965  enum vlc_player_whence whence)
1966 
1967 {
1968  vlc_player_SetCategoryDelay(player, AUDIO_ES, delay, whence);
1969 }
1970 
1971 /**
1972  * Helper to get the subtitle delay
1973  */
1974 static inline vlc_tick_t
1977  return vlc_player_GetCategoryDelay(player, SPU_ES);
1978 }
1979 
1980 /**
1981  * Helper to set the subtitle delay
1982  */
1983 static inline void
1985  enum vlc_player_whence whence)
1986 {
1987  vlc_player_SetCategoryDelay(player, SPU_ES, delay, whence);
1988 }
1989 
1990 /**
1991  * Set the associated subtitle FPS
1992  *
1993  * In order to correct the rate of the associated media according to this FPS
1994  * and the media video FPS.
1995  *
1996  * @note A successful call will trigger the
1997  * vlc_player_cbs.on_associated_subs_fps_changed event.
1998  *
1999  * @warning this function will change the rate of all external subtitle files
2000  * associated with the current media.
2001  *
2002  * @param player locked player instance
2003  * @param fps FPS of the subtitle file
2004  */
2005 VLC_API void
2006 vlc_player_SetAssociatedSubsFPS(vlc_player_t *player, float fps);
2007 
2008 /**
2009  * Get the associated subtitle FPS
2010  *
2011  * @param player locked player instance
2012  * @return fps
2013  */
2014 VLC_API float
2016 
2017 /** @} vlc_player__tracks_sync */
2018 
2019 /**
2020  * @defgroup vlc_player__teletext Teletext control
2021  * @{
2022  */
2023 
2024 /**
2025  * Check if the media has a teletext menu
2026  *
2027  * @see vlc_player_cbs.on_teletext_menu_changed
2028  *
2029  * @param player locked player instance
2030  * @return true if the media has a teletext menu
2031  */
2032 VLC_API bool
2034 
2035 /**
2036  * Enable or disable teletext
2037  *
2038  * This function has an effect only if the player has a teletext menu.
2039  *
2040  * @note A successful call will trigger the
2041  * vlc_player_cbs.on_teletext_enabled_changed event.
2042  *
2043  * @param player locked player instance
2044  * @param enabled true to enable
2045  */
2046 VLC_API void
2047 vlc_player_SetTeletextEnabled(vlc_player_t *player, bool enabled);
2048 
2049 /**
2050  * Check if teletext is enabled
2051  *
2052  * @see vlc_player_cbs.on_teletext_enabled_changed
2053  *
2054  * @param player locked player instance
2055  */
2056 VLC_API bool
2058 
2059 /**
2060  * Select a teletext page or do an action from a key
2061  *
2062  * This function has an effect only if the player has a teletext menu.
2063  *
2064  * @note Page keys can be the following: @ref VLC_PLAYER_TELETEXT_KEY_RED,
2065  * @ref VLC_PLAYER_TELETEXT_KEY_GREEN, @ref VLC_PLAYER_TELETEXT_KEY_YELLOW,
2066  * @ref VLC_PLAYER_TELETEXT_KEY_BLUE or @ref VLC_PLAYER_TELETEXT_KEY_INDEX.
2067 
2068  * @note A successful call will trigger the
2069  * vlc_player_cbs.on_teletext_page_changed event.
2070  *
2071  * @param player locked player instance
2072  * @param page a page in the range ]0;888] or a valid key
2073  */
2074 VLC_API void
2075 vlc_player_SelectTeletextPage(vlc_player_t *player, unsigned page);
2076 
2077 /**
2078  * Get the current teletext page
2079  *
2080  * @see vlc_player_cbs.on_teletext_page_changed
2081  *
2082  * @param player locked player instance
2083  */
2084 VLC_API unsigned
2086 
2087 /**
2088  * Enable or disable teletext transparency
2089  *
2090  * This function has an effect only if the player has a teletext menu.
2091 
2092  * @note A successful call will trigger the
2093  * vlc_player_cbs.on_teletext_transparency_changed event.
2094  *
2095  * @param player locked player instance
2096  * @param enabled true to enable
2097  */
2098 VLC_API void
2099 vlc_player_SetTeletextTransparency(vlc_player_t *player, bool enabled);
2100 
2101 /**
2102  * Check if teletext is transparent
2103  *
2104  * @param player locked player instance
2105  */
2106 VLC_API bool
2108 
2109 /** @} vlc_player__teletext */
2110 
2111 /**
2112  * @defgroup vlc_player__renderer External renderer control
2113  * @{
2114  */
2115 
2116 /**
2117  * Set the renderer
2118  *
2119  * Valid for the current media and all future ones.
2120  *
2121  * @note A successful call will trigger the vlc_player_cbs.on_renderer_changed
2122  * event.
2123  *
2124  * @param player locked player instance
2125  * @param renderer a valid renderer item or NULL (to disable it), the item will
2126  * be held by the player
2127  */
2128 VLC_API void
2130 
2131 /**
2132  * Get the renderer
2133  *
2134  * @see vlc_player_cbs.on_renderer_changed
2135  *
2136  * @param player locked player instance
2137  * @return the renderer item set by vlc_player_SetRenderer()
2138  */
2141 
2142 /** @} vlc_player__renderer */
2143 
2144 /**
2145  * @defgroup vlc_player__aout Audio output control
2146  * @{
2147  */
2148 
2149 /**
2150  * Player aout listener opaque structure.
2151  *
2152  * This opaque structure is returned by vlc_player_aout_AddListener() and can
2153  * be used to remove the listener via vlc_player_aout_RemoveListener().
2154  */
2155 typedef struct vlc_player_aout_listener_id vlc_player_aout_listener_id;
2157 /**
2158  * Player aout callbacks
2159  *
2160  * Can be registered with vlc_player_aout_AddListener().
2161  *
2162  * @warning To avoid deadlocks, users should never call audio_output_t and
2163  * vlc_player_t functions from these callbacks.
2164  */
2165 struct vlc_player_aout_cbs
2167  /**
2168  * Called when the volume has changed
2169  *
2170  * @see vlc_player_aout_SetVolume()
2171  *
2172  * @param aout the main aout of the player
2173  * @param new_volume volume in the range [0;2.f]
2174  * @param data opaque pointer set by vlc_player_aout_AddListener()
2175  */
2176  void (*on_volume_changed)(audio_output_t *aout, float new_volume,
2177  void *data);
2178 
2179  /**
2180  * Called when the mute state has changed
2181  *
2182  * @see vlc_player_aout_Mute()
2183  *
2184  * @param aout the main aout of the player
2185  * @param new_mute true if muted
2186  * @param data opaque pointer set by vlc_player_aout_AddListener()
2187  */
2188  void (*on_mute_changed)(audio_output_t *aout, bool new_muted,
2189  void *data);
2190 
2191  /**
2192  * Called when the audio device has changed
2193  *
2194  * @param aout the main aout of the player
2195  * @param device the device name
2196  * @param data opaque pointer set by vlc_player_aout_AddListener()
2197  */
2198  void (*on_device_changed)(audio_output_t *aout, const char *device,
2199  void *data);
2200 };
2201 
2202 /**
2203  * Get the audio output
2204  *
2205  * @warning The returned pointer must be released with aout_Release().
2206  *
2207  * @param player player instance
2208  * @return a valid audio_output_t * or NULL (if there is no aouts)
2209  */
2212 
2213 /**
2214  * Add a listener callback for audio output events
2215  *
2216  * @note The player instance doesn't need to be locked for vlc_player_aout_*()
2217  * functions.
2218  * @note Every registered callbacks need to be removed by the caller with
2219  * vlc_player_aout_RemoveListener().
2220  *
2221  * @param player player instance
2222  * @param cbs pointer to a vlc_player_aout_cbs structure, the structure must be
2223  * valid during the lifetime of the player
2224  * @param cbs_data opaque pointer used by the callbacks
2225  * @return a valid listener id, or NULL in case of allocation error
2226  */
2227 VLC_API vlc_player_aout_listener_id *
2229  const struct vlc_player_aout_cbs *cbs,
2230  void *cbs_data);
2231 
2232 /**
2233  * Remove a aout listener callback
2234  *
2235  * @param player player instance
2236  * @param listener_id listener id returned by vlc_player_aout_AddListener()
2237  */
2238 VLC_API void
2240  vlc_player_aout_listener_id *listener_id);
2241 
2242 /**
2243  * Get the audio volume
2244  *
2245  * @note The player instance doesn't need to be locked for vlc_player_aout_*()
2246  * functions.
2247  *
2248  * @see vlc_player_aout_cbs.on_volume_changed
2249  *
2250  * @param player player instance
2251  * @return volume in the range [0;2.f] or -1.f if there is no audio outputs
2252  * (independent of mute)
2253  */
2254 VLC_API float
2256 
2257 /**
2258  * Set the audio volume
2259  *
2260  * @note The player instance doesn't need to be locked for vlc_player_aout_*()
2261  * functions.
2262  *
2263  * @note A successful call will trigger the
2264  * vlc_player_vout_cbs.on_volume_changed event.
2265  *
2266  * @param player player instance
2267  * @param volume volume in the range [0;2.f]
2268  * @return VLC_SUCCESS or VLC_EGENERIC if there is no audio outputs
2269  */
2270 VLC_API int
2271 vlc_player_aout_SetVolume(vlc_player_t *player, float volume);
2272 
2273 /**
2274  * Increment the audio volume
2275  *
2276  * @see vlc_player_aout_SetVolume()
2277  *
2278  * @param player player instance
2279  * @param steps number of "volume-step"
2280  * @param result pointer to store the resulting volume (can be NULL)
2281  * @return VLC_SUCCESS or VLC_EGENERIC if there is no audio outputs
2282  */
2283 VLC_API int
2284 vlc_player_aout_IncrementVolume(vlc_player_t *player, int steps, float *result);
2285 
2286 /**
2287  * Helper to decrement the audio volume
2288  */
2289 static inline int
2290 vlc_player_aout_DecrementVolume(vlc_player_t *player, int steps, float *result)
2292  return vlc_player_aout_IncrementVolume(player, -steps, result);
2293 }
2294 
2295 /**
2296  * Check if the audio output is muted
2297  *
2298  * @note The player instance doesn't need to be locked for vlc_player_aout_*()
2299  * functions.
2300  *
2301  * @see vlc_player_aout_cbs.on_mute_changed
2302  *
2303  * @param player player instance
2304  * @return 0 if not muted, 1 if muted, -1 if there is no audio outputs
2305  */
2306 VLC_API int
2308 
2309 /**
2310  * Mute or unmute the audio output
2311  *
2312  * @note The player instance doesn't need to be locked for vlc_player_aout_*()
2313  * functions.
2314  *
2315  * @note A successful call will trigger the
2316  * vlc_player_aout_cbs.on_mute_changed event.
2317  *
2318  * @param player player instance
2319  * @param mute true to mute
2320  * @return VLC_SUCCESS or VLC_EGENERIC if there is no audio outputs
2321  */
2322 VLC_API int
2323 vlc_player_aout_Mute(vlc_player_t *player, bool mute);
2324 
2325 /**
2326  * Helper to toggle the mute state
2327  */
2328 static inline int
2331  return vlc_player_aout_Mute(player,
2332  !vlc_player_aout_IsMuted(player));
2333 }
2334 
2335 /**
2336  * Enable or disable an audio filter
2337  *
2338  * @see aout_EnableFilter()
2339  *
2340  * @return VLC_SUCCESS or VLC_EGENERIC if there is no audio outputs
2341  */
2342 VLC_API int
2343 vlc_player_aout_EnableFilter(vlc_player_t *player, const char *name, bool add);
2344 
2345 /** @} vlc_player__aout */
2346 
2347 /**
2348  * @defgroup vlc_player__vout Video output control
2349  * @{
2350  */
2351 
2352 /**
2353  * Player vout listener opaque structure.
2354  *
2355  * This opaque structure is returned by vlc_player_vout_AddListener() and can
2356  * be used to remove the listener via vlc_player_vout_RemoveListener().
2357  */
2358 typedef struct vlc_player_vout_listener_id vlc_player_vout_listener_id;
2360 /**
2361  * action of vlc_player_cbs.on_vout_changed callback
2362  */
2367 };
2368 
2369 /**
2370  * Player vout callbacks
2371  *
2372  * Can be registered with vlc_player_vout_AddListener().
2373  *
2374  * @note The state changed from the callbacks can be either applied on the
2375  * player (and all future video outputs), or on a specified video output. The
2376  * state is applied on the player when the vout argument is NULL.
2377  *
2378  * @warning To avoid deadlocks, users should never call vout_thread_t and
2379  * vlc_player_t functions from these callbacks.
2380  */
2381 struct vlc_player_vout_cbs
2383  /**
2384  * Called when the player and/or vout fullscreen state has changed
2385  *
2386  * @see vlc_player_vout_SetFullscreen()
2387  *
2388  * @param vout cf. vlc_player_vout_cbs note
2389  * @param enabled true when fullscreen is enabled
2390  * @param data opaque pointer set by vlc_player_vout_AddListener()
2391  */
2392  void (*on_fullscreen_changed)(vout_thread_t *vout, bool enabled,
2393  void *data);
2394 
2395  /**
2396  * Called when the player and/or vout wallpaper mode has changed
2397  *
2398  * @see vlc_player_vout_SetWallpaperModeEnabled()
2399  *
2400  * @param vout cf. vlc_player_vout_cbs note
2401  * @param enabled true when wallpaper mode is enabled
2402  * @param data opaque pointer set by vlc_player_vout_AddListener()
2403  */
2404  void (*on_wallpaper_mode_changed)(vout_thread_t *vout, bool enabled,
2405  void *data);
2406 };
2407 
2408 
2409 /**
2410  * Get and hold the main video output
2411  *
2412  * @warning the returned vout_thread_t * must be released with vout_Release().
2413  * @see vlc_players_cbs.on_vout_changed
2414  *
2415  * @note The player is guaranteed to always hold one valid vout. Only vout
2416  * variables can be changed from this instance. The vout returned before
2417  * playback is not necessarily the same one that will be used for playback.
2418  *
2419  * @param player player instance
2420  * @return a valid vout_thread_t * or NULL, cf. warning
2421  */
2424 
2425 /**
2426  * Get and hold the list of video output
2427  *
2428  * @warning All vout_thread_t * element of the array must be released with
2429  * vout_Release(). The returned array must be freed.
2430  *
2431  * @see vlc_players_cbs.on_vout_changed
2432  *
2433  * @param player player instance
2434  * @param count valid pointer to store the array count
2435  * @return a array of vout_thread_t * or NULL, cf. warning
2436  */
2438 vlc_player_vout_HoldAll(vlc_player_t *player, size_t *count);
2439 
2440 /**
2441  * Add a listener callback for video output events
2442  *
2443  * @note The player instance doesn't need to be locked for vlc_player_vout_*()
2444  * functions.
2445  * @note Every registered callbacks need to be removed by the caller with
2446  * vlc_player_vout_RemoveListener().
2447  *
2448  * @param player player instance
2449  * @param cbs pointer to a vlc_player_vout_cbs structure, the structure must be
2450  * valid during the lifetime of the player
2451  * @param cbs_data opaque pointer used by the callbacks
2452  * @return a valid listener id, or NULL in case of allocation error
2453  */
2454 VLC_API vlc_player_vout_listener_id *
2456  const struct vlc_player_vout_cbs *cbs,
2457  void *cbs_data);
2458 
2459 /**
2460  * Remove a vout listener callback
2461  *
2462  * @param player player instance
2463  * @param listener_id listener id returned by vlc_player_vout_AddListener()
2464  */
2465 VLC_API void
2467  vlc_player_vout_listener_id *listener_id);
2468 
2469 /**
2470  * Check if the player is fullscreen
2471  *
2472  * @warning The fullscreen state of the player and all vouts can be different.
2473  *
2474  * @note The player instance doesn't need to be locked for vlc_player_vout_*()
2475  * functions.
2476  *
2477  * @see vlc_player_vout_cbs.on_fullscreen_changed
2478  *
2479  * @param player player instance
2480  * @return true if the player is fullscreen
2481  */
2482 VLC_API bool
2484 
2485 /**
2486  * Enable or disable the player fullscreen state
2487  *
2488  * This will have an effect on all current and future vouts.
2489  *
2490  * @note The player instance doesn't need to be locked for vlc_player_vout_*()
2491  * functions.
2492  * @note A successful call will trigger the
2493  * vlc_player_vout_cbs.on_fullscreen_changed event.
2494  *
2495  * @param player player instance
2496  * @param enabled true to enable fullscreen
2497  */
2498 VLC_API void
2499 vlc_player_vout_SetFullscreen(vlc_player_t *player, bool enabled);
2500 
2501 /**
2502  * Helper to toggle the player fullscreen state
2503  */
2504 static inline void
2508  !vlc_player_vout_IsFullscreen(player));
2509 }
2510 
2511 /**
2512  * Check if the player has wallpaper-mode enaled
2513  *
2514  * @warning The wallpaper-mode state of the player and all vouts can be
2515  * different.
2516  *
2517  * @note The player instance doesn't need to be locked for vlc_player_vout_*()
2518  * functions.
2519  *
2520  * @see vlc_player_vout_cbs.on_wallpaper_mode_changed
2521  *
2522  * @param player player instance
2523  * @return true if the player is fullscreen
2524  */
2525 VLC_API bool
2527 
2528 /**
2529  * Enable or disable the player wallpaper-mode
2530  *
2531  * This will have an effect on all current and future vouts.
2532  *
2533  * @note The player instance doesn't need to be locked for vlc_player_vout_*()
2534  * functions.
2535  * @note A successful call will trigger the
2536  * vlc_player_vout_cbs.on_wallpaper_mode_changed event.
2537  *
2538  * @param player player instance
2539  * @param enabled true to enable wallpaper-mode
2540  */
2541 VLC_API void
2543 
2544 /**
2545  * Helper to toggle the player wallpaper-mode state
2546  */
2547 static inline void
2552 }
2553 
2554 /**
2555  * Take a snapshot on all vouts
2556  *
2557  * @param player player instance
2558  */
2559 VLC_API void
2561 
2562 /**
2563  * Display an OSD message on all vouts
2564  *
2565  * @param player player instance
2566  * @param fmt format string
2567  */
2568 VLC_API void
2569 vlc_player_osd_Message(vlc_player_t *player, const char *fmt, ...);
2570 
2571 /** @} vlc_player__vout */
2572 
2573 /**
2574  * @defgroup vlc_player__events Player events
2575  * @{
2576  */
2577 
2578 /**
2579  * Player listener opaque structure.
2580  *
2581  * This opaque structure is returned by vlc_player_AddListener() and can be
2582  * used to remove the listener via vlc_player_RemoveListener().
2583  */
2584 typedef struct vlc_player_listener_id vlc_player_listener_id;
2586 /**
2587  * Action of vlc_player_cbs.on_track_list_changed,
2588  * vlc_player_cbs.on_program_list_changed callbacks
2589  */
2595 };
2596 
2597 /**
2598  * Player callbacks
2599  *
2600  * Can be registered with vlc_player_AddListener().
2601  *
2602  * All callbacks are called with the player locked (cf. vlc_player_Lock()) and
2603  * from any threads (and even synchronously from a vlc_player function in some
2604  * cases). It is safe to call any vlc_player functions from these callbacks
2605  * except vlc_player_Delete().
2606  *
2607  * @warning To avoid deadlocks, users should never call vlc_player functions
2608  * with an external mutex locked and lock this same mutex from a player
2609  * callback.
2610  */
2611 struct vlc_player_cbs
2613  /**
2614  * Called when the current media has changed
2615  *
2616  * @note This can be called from the PLAYING state (when the player plays
2617  * the next media internally) or from the STOPPED state (from
2618  * vlc_player_SetCurrentMedia() or from an internal transition).
2619  *
2620  * @see vlc_player_SetCurrentMedia()
2621  * @see vlc_player_InvalidateNextMedia()
2622  *
2623  * @param player locked player instance
2624  * @param new_media new media currently played or NULL (when there is no
2625  * more media to play)
2626  * @param data opaque pointer set by vlc_player_AddListener()
2627  */
2628  void (*on_current_media_changed)(vlc_player_t *player,
2629  input_item_t *new_media, void *data);
2630 
2631  /**
2632  * Called when the player state has changed
2633  *
2634  * @see vlc_player_state
2635  *
2636  * @param player locked player instance
2637  * @param new_state new player state
2638  * @param data opaque pointer set by vlc_player_AddListener()
2639  */
2640  void (*on_state_changed)(vlc_player_t *player,
2641  enum vlc_player_state new_state, void *data);
2642 
2643  /**
2644  * Called when a media triggered an error
2645  *
2646  * Can be called from any states. When it happens the player will stop
2647  * itself. It is safe to play an other media or event restart the player
2648  * (This will reset the error state).
2649  *
2650  * @param player locked player instance
2651  * @param error player error
2652  * @param data opaque pointer set by vlc_player_AddListener()
2653  */
2654  void (*on_error_changed)(vlc_player_t *player,
2655  enum vlc_player_error error, void *data);
2656 
2657  /**
2658  * Called when the player buffering (or cache) has changed
2659  *
2660  * This event is always called with the 0 and 1 values before a playback
2661  * (in case of success). Values in between depends on the media type.
2662  *
2663  * @param player locked player instance
2664  * @param new_buffering buffering in the range [0:1]
2665  * @param data opaque pointer set by vlc_player_AddListener()
2666  */
2667  void (*on_buffering_changed)(vlc_player_t *player,
2668  float new_buffering, void *data);
2669 
2670  /**
2671  * Called when the player rate has changed
2672  *
2673  * Triggered by vlc_player_ChangeRate(), not sent when the media starts
2674  * with the default rate (1.f)
2675  *
2676  * @param player locked player instance
2677  * @param new_rate player
2678  * @param data opaque pointer set by vlc_player_AddListener()
2679  */
2680  void (*on_rate_changed)(vlc_player_t *player,
2681  float new_rate, void *data);
2682 
2683  /**
2684  * Called when the media capabilities has changed
2685  *
2686  * Always called when the media is opening. Can be called during playback.
2687  *
2688  * @param player locked player instance
2689  * @param old_caps old player capabilities
2690  * @param new_caps new player capabilities
2691  * @param data opaque pointer set by vlc_player_AddListener()
2692  */
2693  void (*on_capabilities_changed)(vlc_player_t *player,
2694  int old_caps, int new_caps, void *data);
2695 
2696  /**
2697  * Called when the player position has changed
2698  *
2699  * @note A started and playing media doesn't have necessarily a valid time.
2700  *
2701  * @param player locked player instance
2702  * @param new_time a valid time or VLC_TICK_INVALID
2703  * @param new_pos a valid position
2704  * @param data opaque pointer set by vlc_player_AddListener()
2705  */
2706  void (*on_position_changed)(vlc_player_t *player,
2707  vlc_tick_t new_time, float new_pos, void *data);
2708 
2709  /**
2710  * Called when the media length has changed
2711  *
2712  * May be called when the media is opening or during playback.
2713  *
2714  * @note A started and playing media doesn't have necessarily a valid length.
2715  *
2716  * @param player locked player instance
2717  * @param new_length a valid time or VLC_TICK_INVALID
2718  * @param data opaque pointer set by vlc_player_AddListener()
2719  */
2720  void (*on_length_changed)(vlc_player_t *player,
2721  vlc_tick_t new_length, void *data);
2722 
2723  /**
2724  * Called when a track is added, removed, or updated
2725  *
2726  * @note The track is only valid from this callback context. Users should
2727  * duplicate this track via vlc_player_track_Dup() if they want to use it
2728  * from an other context.
2729  *
2730  * @param player locked player instance
2731  * @param action added, removed or updated
2732  * @param track valid track
2733  * @param data opaque pointer set by vlc_player_AddListener()
2734  */
2735  void (*on_track_list_changed)(vlc_player_t *player,
2737  const struct vlc_player_track *track, void *data);
2738 
2739  /**
2740  * Called when a new track is selected and/or unselected
2741  *
2742  * @note This event can be called with both unselected_id and selected_id
2743  * valid. This mean that a new track is replacing the old one.
2744  *
2745  * @param player locked player instance
2746  * @param unselected_id valid track id or NULL (when nothing is unselected)
2747  * @param selected_id valid track id or NULL (when nothing is selected)
2748  * @param data opaque pointer set by vlc_player_AddListener()
2749  */
2750  void (*on_track_selection_changed)(vlc_player_t *player,
2751  vlc_es_id_t *unselected_id, vlc_es_id_t *selected_id, void *data);
2752 
2753  /**
2754  * Called when a track delay has changed
2755  *
2756  * @param player locked player instance
2757  * @param es_id valid track id
2758  * @param delay a valid delay or INT64_MAX if the delay of this track is
2759  * canceled
2760  */
2761  void (*on_track_delay_changed)(vlc_player_t *player,
2762  vlc_es_id_t *es_id, vlc_tick_t delay, void *data);
2763 
2764  /**
2765  * Called when a new program is added, removed or updated
2766  *
2767  * @note The program is only valid from this callback context. Users should
2768  * duplicate this program via vlc_player_program_Dup() if they want to use
2769  * it from an other context.
2770  *
2771  * @param player locked player instance
2772  * @param action added, removed or updated
2773  * @param prgm valid program
2774  * @param data opaque pointer set by vlc_player_AddListener()
2775  */
2776  void (*on_program_list_changed)(vlc_player_t *player,
2778  const struct vlc_player_program *prgm, void *data);
2779 
2780  /**
2781  * Called when a new program is selected and/or unselected
2782  *
2783  * @note This event can be called with both unselected_id and selected_id
2784  * valid. This mean that a new program is replacing the old one.
2785  *
2786  * @param player locked player instance
2787  * @param unselected_id valid program id or -1 (when nothing is unselected)
2788  * @param selected_id valid program id or -1 (when nothing is selected)
2789  * @param data opaque pointer set by vlc_player_AddListener()
2790  */
2791  void (*on_program_selection_changed)(vlc_player_t *player,
2792  int unselected_id, int selected_id, void *data);
2793 
2794  /**
2795  * Called when the media titles has changed
2796  *
2797  * This event is not called when the opening media doesn't have any titles.
2798  * This title list and all its elements are constant. If an element is to
2799  * be updated, a new list will be sent from this callback.
2800  *
2801  * @note Users should hold this list with vlc_player_title_list_Hold() if
2802  * they want to use it from an other context.
2803  *
2804  * @param player locked player instance
2805  * @param titles valid title list or NULL
2806  * @param data opaque pointer set by vlc_player_AddListener()
2807  */
2808  void (*on_titles_changed)(vlc_player_t *player,
2809  vlc_player_title_list *titles, void *data);
2810 
2811  /**
2812  * Called when a new title is selected
2813  *
2814  * There are no events when a title is unselected. Titles are automatically
2815  * unselected when the title list changes. Titles and indexes are always
2816  * valid inside the vlc_player_title_list sent by
2817  * vlc_player_cbs.on_titles_changed.
2818  *
2819  * @param player locked player instance
2820  * @param new_title new selected title
2821  * @param new_idx index of this title
2822  * @param data opaque pointer set by vlc_player_AddListener()
2823  */
2824  void (*on_title_selection_changed)(vlc_player_t *player,
2825  const struct vlc_player_title *new_title, size_t new_idx, void *data);
2826 
2827  /**
2828  * Called when a new chapter is selected
2829  *
2830  * There are no events when a chapter is unselected. Chapters are
2831  * automatically unselected when the title list changes. Titles, chapters
2832  * and indexes are always valid inside the vlc_player_title_list sent by
2833  * vlc_player_cbs.on_titles_changed.
2834  *
2835  * @param player locked player instance
2836  * @param title selected title
2837  * @param title_idx selected title index
2838  * @param chapter new selected chapter
2839  * @param chapter_idx new selected chapter index
2840  * @param data opaque pointer set by vlc_player_AddListener()
2841  */
2842  void (*on_chapter_selection_changed)(vlc_player_t *player,
2843  const struct vlc_player_title *title, size_t title_idx,
2844  const struct vlc_player_chapter *new_chapter, size_t new_chapter_idx,
2845  void *data);
2846 
2847  /**
2848  * Called when the media has a teletext menu
2849  *
2850  * @param player locked player instance
2851  * @param has_teletext_menu true if the media has a teletext menu
2852  * @param data opaque pointer set by vlc_player_AddListener()
2853  */
2854  void (*on_teletext_menu_changed)(vlc_player_t *player,
2855  bool has_teletext_menu, void *data);
2856 
2857  /**
2858  * Called when teletext is enabled or disabled
2859  *
2860  * @see vlc_player_SetTeletextEnabled()
2861  *
2862  * @param player locked player instance
2863  * @param enabled true if teletext is enabled
2864  * @param data opaque pointer set by vlc_player_AddListener()
2865  */
2866  void (*on_teletext_enabled_changed)(vlc_player_t *player,
2867  bool enabled, void *data);
2868 
2869  /**
2870  * Called when the teletext page has changed
2871  *
2872  * @see vlc_player_SelectTeletextPage()
2873  *
2874  * @param player locked player instance
2875  * @param new_page page in the range ]0;888]
2876  * @param data opaque pointer set by vlc_player_AddListener()
2877  */
2878  void (*on_teletext_page_changed)(vlc_player_t *player,
2879  unsigned new_page, void *data);
2880 
2881  /**
2882  * Called when the teletext transparency has changed
2883  *
2884  * @see vlc_player_SetTeletextTransparency()
2885  *
2886  * @param player locked player instance
2887  * @param enabled true is the teletext overlay is transparent
2888  * @param data opaque pointer set by vlc_player_AddListener()
2889  */
2890  void (*on_teletext_transparency_changed)(vlc_player_t *player,
2891  bool enabled, void *data);
2892 
2893  /**
2894  * Called when the player category delay has changed for the current media
2895  *
2896  * @see vlc_player_SetCategoryDelay()
2897  *
2898  * @param player locked player instance
2899  * @param cat AUDIO_ES or SPU_ES
2900  * @param new_delay audio delay
2901  * @param data opaque pointer set by vlc_player_AddListener()
2902  */
2903  void (*on_category_delay_changed)(vlc_player_t *player,
2904  enum es_format_category_e cat, vlc_tick_t new_delay, void *data);
2905 
2906  /**
2907  * Called when associated subtitle has changed
2908  *
2909  * @see vlc_player_SetAssociatedSubsFPS()
2910  *
2911  * @param player locked player instance
2912  * @param sub_fps subtitle fps
2913  * @param data opaque pointer set by vlc_player_AddListener()
2914  */
2915  void (*on_associated_subs_fps_changed)(vlc_player_t *player,
2916  float subs_fps, void *data);
2917 
2918  /**
2919  * Called when a new renderer item is set
2920  *
2921  * @see vlc_player_SetRenderer()
2922  *
2923  * @param player locked player instance
2924  * @param new_item a valid renderer item or NULL (if unset)
2925  * @param data opaque pointer set by vlc_player_AddListener()
2926  */
2927  void (*on_renderer_changed)(vlc_player_t *player,
2928  vlc_renderer_item_t *new_item, void *data);
2929 
2930  /**
2931  * Called when the player recording state has changed
2932  *
2933  * @see vlc_player_SetRecordingEnabled()
2934  *
2935  * @param player locked player instance
2936  * @param recording true if recording is enabled
2937  * @param data opaque pointer set by vlc_player_AddListener()
2938  */
2939  void (*on_recording_changed)(vlc_player_t *player,
2940  bool recording, void *data);
2941 
2942  /**
2943  * Called when the media signal has changed
2944  *
2945  * @param player locked player instance
2946  * @param new_quality signal quality
2947  * @param new_strength signal strength,
2948  * @param data opaque pointer set by vlc_player_AddListener()
2949  */
2950  void (*on_signal_changed)(vlc_player_t *player,
2951  float quality, float strength, void *data);
2952 
2953  /**
2954  * Called when the player has new statisics
2955  *
2956  * @note The stats structure is only valid from this callback context. It
2957  * can be copied in order to use it from an other context.
2958  *
2959  * @param player locked player instance
2960  * @param stats valid stats, only valid from this context
2961  * @param data opaque pointer set by vlc_player_AddListener()
2962  */
2963  void (*on_statistics_changed)(vlc_player_t *player,
2964  const struct input_stats_t *stats, void *data);
2965 
2966  /**
2967  * Called when the A to B loop has changed
2968  *
2969  * @see vlc_player_SetAtoBLoop()
2970  *
2971  * @param player locked player instance
2972  * @param state A, when only A is set, B when both A and B are set, None by
2973  * default
2974  * @param time valid time or VLC_TICK_INVALID of the current state
2975  * @param pos valid pos of the current state
2976  * @param data opaque pointer set by vlc_player_AddListener()
2977  */
2978  void (*on_atobloop_changed)(vlc_player_t *player,
2979  enum vlc_player_abloop new_state, vlc_tick_t time, float pos,
2980  void *data);
2981 
2982  /**
2983  * Called when media stopped action has changed
2984  *
2985  * @see vlc_player_SetMediaStoppedAction()
2986  *
2987  * @param player locked player instance
2988  * @param new_action action to execute when a media is stopped
2989  * @param data opaque pointer set by vlc_player_AddListener()
2990  */
2991  void (*on_media_stopped_action_changed)(vlc_player_t *player,
2992  enum vlc_player_media_stopped_action new_action, void *data);
2993 
2994  /**
2995  * Called when the media meta has changed
2996  *
2997  * @param player locked player instance
2998  * @param media current media
2999  * @param data opaque pointer set by vlc_player_AddListener()
3000  */
3001  void (*on_media_meta_changed)(vlc_player_t *player,
3002  input_item_t *media, void *data);
3003 
3004  /**
3005  * Called when media epg has changed
3006  *
3007  * @param player locked player instance
3008  * @param media current media
3009  * @param data opaque pointer set by vlc_player_AddListener()
3010  */
3011  void (*on_media_epg_changed)(vlc_player_t *player,
3012  input_item_t *media, void *data);
3013 
3014  /**
3015  * Called when the media has new subitems
3016  *
3017  * @param player locked player instance
3018  * @param media current media
3019  * @param new_subitems node representing all media subitems
3020  * @param data opaque pointer set by vlc_player_AddListener()
3021  */
3022  void (*on_media_subitems_changed)(vlc_player_t *player,
3023  input_item_t *media, input_item_node_t *new_subitems, void *data);
3024 
3025  /**
3026  * Called when a vout is started or stopped
3027  *
3028  * @note In case, several media with only one video track are played
3029  * successively, the same vout instance will be started and stopped several
3030  * time.
3031  *
3032  * @param player locked player instance
3033  * @param action started or stopped
3034  * @param vout vout (can't be NULL)
3035  * @param order vout order
3036  * @param es_id the ES id associated with this vout
3037  * @param data opaque pointer set by vlc_player_AddListener()
3038  */
3039  void (*on_vout_changed)(vlc_player_t *player,
3041  enum vlc_vout_order order, vlc_es_id_t *es_id, void *data);
3042 
3043  /**
3044  * Called when the player is corked
3045  *
3046  * The player can be corked when the audio output loose focus or when a
3047  * renderer was paused from the outside.
3048  *
3049  * @note called only if pause on cork was not set to true (by
3050  * vlc_player_SetPauseOnCork())
3051  * @note a cork_count higher than 0 means the player is corked. In that
3052  * case, the user should pause the player and release all external resource
3053  * needed by the player. A value higher than 1 mean that the player was
3054  * corked more than one time (for different reasons). A value of 0 means
3055  * the player is no longer corked. In that case, the user could resume the
3056  * player.
3057  *
3058  * @param player locked player instance
3059  * @param cork_count 0 for uncorked, > 0 for corked
3060  * @param data opaque pointer set by vlc_player_AddListener()
3061  */
3062  void (*on_cork_changed)(vlc_player_t *player, unsigned cork_count,
3063  void *data);
3064 
3065  /**
3066  * Called to query the user about restoring the previous playback position
3067  *
3068  * If this callback isn't provided, the user won't be asked to restore
3069  * the previous playback position, effectively causing
3070  * VLC_PLAYER_RESTORE_PLAYBACK_POS_ASK to be handled as
3071  * VLC_PLAYER_RESTORE_PLAYBACK_POS_NEVER
3072  *
3073  * The implementation can react to this callback by calling
3074  * vlc_player_RestorePlaybackPos(), or by discarding the event.
3075  *
3076  * @param player locked player instance
3077  * @param data opaque pointer set by vlc_player_AddListener()
3078  */
3079  void (*on_playback_restore_queried)(vlc_player_t *player, void *data);
3080 };
3081 
3082 /**
3083  * Add a listener callback
3084  *
3085  * @note Every registered callbacks need to be removed by the caller with
3086  * vlc_player_RemoveListener().
3087  *
3088  * @param player locked player instance
3089  * @param cbs pointer to a vlc_player_cbs structure, the structure must be
3090  * valid during the lifetime of the player
3091  * @param cbs_data opaque pointer used by the callbacks
3092  * @return a valid listener id, or NULL in case of allocation error
3093  */
3094 VLC_API vlc_player_listener_id *
3096  const struct vlc_player_cbs *cbs, void *cbs_data);
3097 
3098 /**
3099  * Remove a listener callback
3100  *
3101  * @param player locked player instance
3102  * @param listener_id listener id returned by vlc_player_AddListener()
3103  */
3104 VLC_API void
3106  vlc_player_listener_id *listener_id);
3107 
3108 /** @} vlc_player__events */
3109 
3110 /**
3111  * @defgroup vlc_player__timer Player timer
3112  * @{
3113  */
3114 
3115 /**
3116  * Player timer opaque structure.
3117  */
3120 /**
3121  * Player timer point
3122  *
3123  * @see vlc_player_timer_cbs.on_update
3124  */
3127  /** Position in the range [0.0f;1.0] */
3128  float position;
3129  /** Rate of the player */
3130  double rate;
3131  /** Valid time >= VLC_TICK_0 or VLC_TICK_INVALID, subtract this time with
3132  * VLC_TICK_0 to get the original value. */
3133  vlc_tick_t ts;
3134  /** Valid length >= VLC_TICK_0 or VLC_TICK_INVALID */
3135  vlc_tick_t length;
3136  /** System date of this record (always valid), this date can be in the
3137  * future or in the past. The special value of INT64_MAX mean that the
3138  * clock was paused when this point was updated. In that case,
3139  * vlc_player_timer_point_Interpolate() will return the current ts/pos of
3140  * this point (there is nothing to interpolate). */
3141  vlc_tick_t system_date;
3142 };
3143 
3144 /**
3145  * Player smpte timecode
3146  *
3147  * @see vlc_player_timer_smpte_cbs
3148  */
3151  /** Hours [0;n] */
3152  unsigned hours;
3153  /** Minutes [0;59] */
3154  unsigned minutes;
3155  /** Seconds [0;59] */
3156  unsigned seconds;
3157  /** Frame number [0;n] */
3158  unsigned frames;
3159  /** Maximum number of digits needed to display the frame number */
3160  unsigned frame_resolution;
3161  /** True if the source is NTSC 29.97fps or 59.94fps DF */
3162  bool drop_frame;
3163 };
3164 
3165 /**
3166  * Player timer callbacks
3167  *
3168  * @see vlc_player_AddTimer
3169  */
3170 struct vlc_player_timer_cbs
3172  /**
3173  * Called when the state or the time changed.
3174  *
3175  * Get notified when the time is updated by the input or output source. The
3176  * input source is the 'demux' or the 'access_demux'. The output source are
3177  * audio and video outputs: an update is received each time a video frame
3178  * is displayed or an audio sample is written. The delay between each
3179  * updates may depend on the input and source type (it can be every 5ms,
3180  * 30ms, 1s or 10s...). The user of this timer may need to update the
3181  * position at a higher frequency from its own mainloop via
3182  * vlc_player_timer_point_Interpolate().
3183  *
3184  * @warning The player is not locked from this callback. It is forbidden
3185  * to call any player functions from here.
3186  *
3187  * @param value always valid, the time corresponding to the state
3188  * @param data opaque pointer set by vlc_player_AddTimer()
3189  */
3190  void (*on_update)(const struct vlc_player_timer_point *value, void *data);
3192  /**
3193  * The player is paused or a discontinuity occurred, likely caused by seek
3194  * from the user or because the playback is stopped. The player user should
3195  * stop its "interpolate" timer.
3196  *
3197  * @param system_date system date of this event, only valid when paused. It
3198  * can be used to interpolate the last updated point to this date in order
3199  * to get the last paused ts/position.
3200  * @param data opaque pointer set by vlc_player_AddTimer()
3201  */
3202  void (*on_discontinuity)(vlc_tick_t system_date, void *data);
3203 };
3204 
3205 /**
3206  * Player smpte timer callbacks
3207  *
3208  * @see vlc_player_AddSmpteTimer
3209  */
3212  /**
3213  * Called when a new frame is displayed
3214 
3215  * @warning The player is not locked from this callback. It is forbidden
3216  * to call any player functions from here.
3217  *
3218  * @param tc always valid, the timecode corresponding to the frame just
3219  * displayed
3220  * @param data opaque pointer set by vlc_player_AddTimer()
3221  */
3222  void (*on_update)(const struct vlc_player_timer_smpte_timecode *tc,
3223  void *data);
3224 };
3225 
3226 /**
3227  * Add a timer in order to get times updates
3228  *
3229  * @param player player instance (locked or not)
3230  * @param min_period corresponds to the minimum period between each updates,
3231  * use it to avoid flood from too many source updates, set it to
3232  * VLC_TICK_INVALID to receive all updates.
3233  * @param cbs pointer to a vlc_player_timer_cbs structure, the structure must
3234  * be valid during the lifetime of the player
3235  * @param cbs_data opaque pointer used by the callbacks
3236  * @return a valid vlc_player_timer_id or NULL in case of memory allocation
3237  * error
3238  */
3240 vlc_player_AddTimer(vlc_player_t *player, vlc_tick_t min_period,
3241  const struct vlc_player_timer_cbs *cbs, void *data);
3242 
3243 /**
3244  * Add a smpte timer in order to get accurate video frame updates
3245  *
3246  * @param player player instance (locked or not)
3247  * @param cbs pointer to a vlc_player_timer_smpte_cbs structure, the structure must
3248  * be valid during the lifetime of the player
3249  * @param cbs_data opaque pointer used by the callbacks
3250  * @return a valid vlc_player_timer_id or NULL in case of memory allocation
3251  * error
3252  */
3255  const struct vlc_player_timer_smpte_cbs *cbs,
3256  void *data);
3257 
3258 /**
3259  * Remove a player timer
3260  *
3261  * @param player player instance (locked or not)
3262  * @param timer timer created by vlc_player_AddTimer()
3263  */
3264 VLC_API void
3266 
3267 /**
3268  * Interpolate the last timer value to now
3269  *
3270  * @param point time update obtained via the vlc_player_timer_cbs.on_update()
3271  * callback
3272  * @param system_now current system date
3273  * @param player_rate rate of the player
3274  * @param out_ts pointer where to set the interpolated ts, subtract this time
3275  * with VLC_TICK_0 to get the original value.
3276  * @param out_pos pointer where to set the interpolated position
3277  * @return VLC_SUCCESS in case of success, an error in the interpolated ts is
3278  * negative (could happen during the buffering step)
3279  */
3280 VLC_API int
3282  vlc_tick_t system_now,
3283  vlc_tick_t *out_ts, float *out_pos);
3284 
3285 /**
3286  * Get the date of the next interval
3287  *
3288  * Can be used to setup an UI timer in order to update some widgets at specific
3289  * interval. A next_interval of VLC_TICK_FROM_SEC(1) can be used to update a
3290  * time widget when the media reaches a new second.
3291  *
3292  * @note The media time doesn't necessarily correspond to the system time, that
3293  * is why this function is needed and use the rate of the current point.
3294  *
3295  * @param point time update obtained via the vlc_player_timer_cbs.on_update()
3296  * @param system_now current system date
3297  * @param interpolated_ts ts returned by vlc_player_timer_point_Interpolate()
3298  * with the same system now
3299  * @param next_interval next interval
3300  * @return the absolute system date of the next interval
3301  */
3304  vlc_tick_t system_now,
3305  vlc_tick_t interpolated_ts,
3306  vlc_tick_t next_interval);
3307 
3308 /** @} vlc_player__timer */
3309 
3310 /** @} vlc_player */
3311 
3312 #endif
void vlc_player_SelectChapterIdx(vlc_player_t *player, size_t index)
Select a chapter index for the current media.
Definition: player.c:917
static void vlc_player_SetTime(vlc_player_t *player, vlc_tick_t time)
Helper to set the absolute time precisely.
Definition: vlc_player.h:753
void vlc_player_program_Delete(struct vlc_player_program *prgm)
Delete a duplicated program.
Definition: track.c:82
int vlc_player_aout_IncrementVolume(vlc_player_t *player, int steps, float *result)
Increment the audio volume.
Definition: aout.c:147
Stop, even if there is a next media to play.
Definition: vlc_player.h:102
void vlc_player_aout_RemoveListener(vlc_player_t *player, vlc_player_aout_listener_id *listener_id)
Remove a aout listener callback.
Definition: aout.c:71
Pause when reaching the end of file.
Definition: vlc_player.h:100
#define VLC_PLAYER_CAP_PAUSE
Player capability: can pause.
Definition: vlc_player.h:360
Player timer point.
Definition: vlc_player.h:3126
vlc_player_nav
Menu (VCD/DVD/BD) and viewpoint navigations.
Definition: vlc_player.h:329
Given time/position.
Definition: vlc_player.h:319
Exit VLC.
Definition: vlc_player.h:104
static input_item_t * vlc_player_HoldCurrentMedia(vlc_player_t *player)
Helper that hold the current media.
Definition: vlc_player.h:421
vlc_tick_t vlc_player_GetEsIdDelay(vlc_player_t *player, vlc_es_id_t *es_id)
Get the delay of a track.
Definition: player.c:1732
static vlc_tick_t vlc_player_GetSubtitleDelay(vlc_player_t *player)
Helper to get the subtitle delay.
Definition: vlc_player.h:1976
void vlc_player_SelectTitle(vlc_player_t *player, const struct vlc_player_title *title)
Select a title for the current media.
Definition: player.c:864
vlc_tick_t vlc_player_GetCategoryDelay(vlc_player_t *player, enum es_format_category_e cat)
Get the delay of an ES category for the current media.
Definition: player.c:1679
static bool vlc_player_IsStarted(vlc_player_t *player)
Helper to get the started state.
Definition: vlc_player.h:519
static void vlc_player_TogglePause(vlc_player_t *player)
Helper to toggle the pause state.
Definition: vlc_player.h:545
void vlc_player_SetStartPaused(vlc_player_t *player, bool start_paused)
Ask to start in a paused state.
Definition: player.c:1226
Definition: vlc_es.h:604
float vlc_player_GetRate(vlc_player_t *player)
Get the rate of the player.
Definition: player.c:1294
Definition: player.h:208
vlc_renderer_item_t * vlc_player_GetRenderer(vlc_player_t *player)
Get the renderer.
Definition: player.c:1479
Definition: vlc_player.h:353
void vlc_player_SeekByPos(vlc_player_t *player, float position, enum vlc_player_seek_speed speed, enum vlc_player_whence whence)
Seek the current media by position.
Definition: player.c:1410
Definition: vlc_player.h:2595
static void vlc_player_JumpPos(vlc_player_t *player, float jumppos)
Helper to jump the position precisely.
Definition: vlc_player.h:741
enum vlc_player_state vlc_player_GetState(vlc_player_t *player)
Get the state of the player.
Definition: player.c:1273
void vlc_player_SelectTitleIdx(vlc_player_t *player, size_t index)
Select a title index for the current media.
Definition: player.c:855
Describes an input and is used to spawn input_thread_t objects.
Definition: vlc_input_item.h:77
int vlc_player_aout_EnableFilter(vlc_player_t *player, const char *name, bool add)
Enable or disable an audio filter.
Definition: aout.c:183
Activate the popup Menu (for BD)
Definition: vlc_player.h:342
const struct vlc_player_program * vlc_player_GetProgram(vlc_player_t *player, int group_id)
Get a program from an ES group identifier.
Definition: player.c:277
const struct vlc_player_track * vlc_player_GetTrack(vlc_player_t *player, vlc_es_id_t *es_id)
Get a track from an ES identifier.
Definition: player.c:398
static void vlc_player_ToggleSubtitle(vlc_player_t *player)
Helper to toggle subtitles.
Definition: vlc_player.h:1854
Player vout callbacks.
Definition: vlc_player.h:2382
void vlc_player_ChangeRate(vlc_player_t *player, float rate)
Change the rate of the player.
Definition: player.c:1304
void vlc_player_SelectChapter(vlc_player_t *player, const struct vlc_player_title *title, size_t chapter_idx)
Select a chapter for the current media.
Definition: player.c:873
bool vlc_player_vout_IsWallpaperModeEnabled(vlc_player_t *player)
Check if the player has wallpaper-mode enaled.
Definition: vout.c:189
vout_thread_t * vlc_player_vout_Hold(vlc_player_t *player)
Get and hold the main video output.
Definition: vout.c:43
void vlc_player_SetMediaStoppedAction(vlc_player_t *player, enum vlc_player_media_stopped_action action)
Setup an action when a media is stopped.
Definition: player.c:1215
void vlc_player_SelectProgram(vlc_player_t *player, int group_id)
Select a program from an ES group identifier.
Definition: player.c:290
void vlc_player_SetTrackCategoryEnabled(vlc_player_t *player, enum es_format_category_e cat, bool enabled)
Enable or disable a track category.
Definition: player.c:1753
int vlc_player_aout_IsMuted(vlc_player_t *player)
Check if the audio output is muted.
Definition: aout.c:159
static void vlc_player_RestartTrackCategory(vlc_player_t *player, enum es_format_category_e cat)
Helper to restart all selected tracks from an ES category.
Definition: vlc_player.h:1708
Definition: vlc_player.h:292
Definition: vlc_input_item.h:191
vlc_player_restore_playback_pos
Definition: vlc_player.h:377
int vlc_player_AddAssociatedMedia(vlc_player_t *player, enum es_format_category_e cat, const char *uri, bool select, bool notify, bool check_ext)
Add an associated (or external) media to the current media.
Definition: player.c:1061
void vlc_player_SetRenderer(vlc_player_t *player, vlc_renderer_item_t *renderer)
Set the renderer.
Definition: player.c:1459
unsigned vlc_player_GetTeletextPage(vlc_player_t *player)
Get the current teletext page.
Definition: player.c:812
void vlc_player_NextVideoFrame(vlc_player_t *player)
Pause and display the next video frame.
Definition: player.c:1261
static void vlc_player_SetSubtitleEnabled(vlc_player_t *player, bool enabled)
Helper to enable or disable subtitle tracks.
Definition: vlc_player.h:1836
static bool vlc_player_IsVideoEnabled(vlc_player_t *player)
Helper to check if video tracks are enabled.
Definition: vlc_player.h:1809
vlc_tick_t system_date
System date of this record (always valid), this date can be in the future or in the past...
Definition: vlc_player.h:3142
void vlc_player_SelectNextProgram(vlc_player_t *player)
Select the next program.
Definition: player.c:343
static void vlc_player_UnselectTrackCategory(vlc_player_t *player, enum es_format_category_e cat)
Helper to unselect all tracks from an ES category.
Definition: vlc_player.h:1667
size_t chapter_count
Number of chapters, can be 0.
Definition: vlc_player.h:966
Do a precise seek.
Definition: vlc_player.h:304
#define VLC_DEPRECATED
Deprecated functions or compound members annotation.
Definition: vlc_common.h:119
void vlc_player_RestartEsId(vlc_player_t *player, vlc_es_id_t *es_id)
Restart a track from an ES identifier.
Definition: player.c:708
Activate disc Root Menu.
Definition: vlc_player.h:344
Definition: player.h:136
static void vlc_player_SetTimeFast(vlc_player_t *player, vlc_tick_t time)
Helper to set the absolute time fast.
Definition: vlc_player.h:763
Player aout callbacks.
Definition: vlc_player.h:2166
static bool vlc_player_CanChangeRate(vlc_player_t *player)
Helper to get the change-rate capability.
Definition: vlc_player.h:591
The player is paused.
Definition: vlc_player.h:273
void vlc_player_SelectCategoryLanguage(vlc_player_t *player, enum es_format_category_e cat, const char *lang)
Select the language for an ES category.
Definition: player.c:717
void vlc_player_SetTeletextEnabled(vlc_player_t *player, bool enabled)
Enable or disable teletext.
Definition: player.c:752
enum vlc_player_abloop vlc_player_GetAtoBLoop(vlc_player_t *player, vlc_tick_t *a_time, float *a_pos, vlc_tick_t *b_time, float *b_pos)
Get the A to B loop status.
Definition: player.c:1543
Player smpte timer callbacks.
Definition: vlc_player.h:3211
void vlc_player_SelectTeletextPage(vlc_player_t *player, unsigned page)
Select a teletext page or do an action from a key.
Definition: player.c:765
const struct vlc_player_chapter * chapters
Array of chapters, can be NULL.
Definition: vlc_player.h:968
const struct input_stats_t * vlc_player_GetStatistics(vlc_player_t *player)
Get the statistics of the current media.
Definition: player.c:1809
static bool vlc_player_CanPause(vlc_player_t *player)
Helper to get the pause capability.
Definition: vlc_player.h:582
static bool vlc_player_CanRewind(vlc_player_t *player)
Helper to get the rewindable capability.
Definition: vlc_player.h:600
Definition: vlc_player.h:291
int vlc_player_GetCapabilities(vlc_player_t *player)
Get the player capabilities.
Definition: player.c:1287
Player track structure.
Definition: vlc_player.h:1327
vlc_tick_t vlc_player_timer_point_GetNextIntervalDate(const struct vlc_player_timer_point *point, vlc_tick_t system_now, vlc_tick_t interpolated_ts, vlc_tick_t next_interval)
Get the date of the next interval.
Definition: timer.c:505
The player is started.
Definition: vlc_player.h:258
void vlc_player_vout_RemoveListener(vlc_player_t *player, vlc_player_vout_listener_id *listener_id)
Remove a vout listener callback.
Definition: vout.c:89
vlc_player_timer_id * vlc_player_AddTimer(vlc_player_t *player, vlc_tick_t min_period, const struct vlc_player_timer_cbs *cbs, void *data)
Add a timer in order to get times updates.
Definition: timer.c:408
vlc_es_id_t * es_id
Id used for any player actions, like vlc_player_SelectEsId()
Definition: vlc_player.h:1330
vlc_player_error
Error of the player.
Definition: vlc_player.h:289
Player smpte timecode.
Definition: vlc_player.h:3150
Player timer callbacks.
Definition: vlc_player.h:3171
Definition: vlc_player.h:380
int vlc_player_Start(vlc_player_t *player)
Start the playback of the current media.
Definition: player.c:1148
Activate the navigation item selected.
Definition: vlc_player.h:332
enum vlc_player_error vlc_player_GetError(vlc_player_t *player)
Get the error state of the player.
Definition: player.c:1280
Definition: vlc_es.h:605
static void vlc_player_RestartTrack(vlc_player_t *player, const struct vlc_player_track *track)
Helper to restart a track.
Definition: vlc_player.h:1698
static const struct vlc_player_track * vlc_player_GetSelectedTrack(vlc_player_t *player, enum es_format_category_e cat)
Helper to get the selected track from an ES category.
Definition: vlc_player.h:1506
void vlc_player_SelectNextTrack(vlc_player_t *player, enum es_format_category_e cat)
Select the next track.
Definition: player.c:681
static size_t vlc_player_GetAudioTrackCount(vlc_player_t *player)
Helper to get the audio track count.
Definition: vlc_player.h:1414
vlc_player_seek_speed
Seek speed type.
Definition: vlc_player.h:301
void vlc_player_track_Delete(struct vlc_player_track *track)
Delete a duplicated track.
Definition: track.c:149
static size_t vlc_player_GetSubtitleTrackCount(vlc_player_t *player)
Helper to get the subtitle track count.
Definition: vlc_player.h:1432
vout_thread_t ** vlc_player_vout_HoldAll(vlc_player_t *player, size_t *count)
Get and hold the list of video output.
Definition: vout.c:50
size_t vlc_player_GetProgramCount(vlc_player_t *player)
Get the number of programs.
Definition: player.c:257
Definition: renderer_discovery.c:34
Definition: vlc_player.h:352
es_format_category_e
ES Categories.
Definition: vlc_es.h:600
vlc_player_list_action
Action of vlc_player_cbs.on_track_list_changed, vlc_player_cbs.on_program_list_changed callbacks...
Definition: vlc_player.h:2591
static const struct vlc_player_program * vlc_player_GetSelectedProgram(vlc_player_t *player)
Helper to get the current selected program.
Definition: vlc_player.h:1275
static void vlc_player_JumpTime(vlc_player_t *player, vlc_tick_t jumptime)
Helper to jump the time precisely.
Definition: vlc_player.h:773
Definition: vlc_player.h:379
int vlc_player_Stop(vlc_player_t *player)
Stop the playback of the current media.
Definition: player.c:1197
void vlc_player_vout_Snapshot(vlc_player_t *player)
Take a snapshot on all vouts.
Definition: vout.c:206
void vlc_player_DisplayPosition(vlc_player_t *player)
Display the player position on the vout OSD.
Definition: player.c:1398
static bool vlc_player_IsSubtitleEnabled(vlc_player_t *player)
Helper to check if subtitle tracks are enabled.
Definition: vlc_player.h:1845
void vlc_player_Lock(vlc_player_t *player)
Lock the player.
Definition: player.c:953
int vlc_player_timer_point_Interpolate(const struct vlc_player_timer_point *point, vlc_tick_t system_now, vlc_tick_t *out_ts, float *out_pos)
Interpolate the last timer value to now.
Definition: timer.c:464
Player program structure.
Definition: vlc_player.h:1174
void vlc_player_SetTeletextTransparency(vlc_player_t *player, bool enabled)
Enable or disable teletext transparency.
Definition: player.c:779
void vlc_player_vout_SetFullscreen(vlc_player_t *player, bool enabled)
Enable or disable the player fullscreen state.
Definition: vout.c:181
Definition: player.h:129
int64_t vlc_tick_t
High precision date or time interval.
Definition: vlc_tick.h:45
vlc_player_select_policy
Player selection policy.
Definition: vlc_player.h:1301
static vlc_tick_t vlc_player_GetAudioDelay(vlc_player_t *player)
Helper to get the audio delay.
Definition: vlc_player.h:1956
Select a navigation item above or move the viewpoint up.
Definition: vlc_player.h:334
int vlc_player_SetAtoBLoop(vlc_player_t *player, enum vlc_player_abloop abloop)
Enable A to B loop of the current media.
Definition: player.c:1486
static bool vlc_player_IsAudioEnabled(vlc_player_t *player)
Helper to check if audio tracks are enabled.
Definition: vlc_player.h:1827
vlc_player_abloop
A to B loop state.
Definition: vlc_player.h:350
vlc_player_media_stopped_action
Action when the player is stopped.
Definition: vlc_player.h:96
vlc_player_whence
Player seek/delay directive.
Definition: vlc_player.h:316
unsigned vlc_player_SelectEsIdList(vlc_player_t *player, enum es_format_category_e cat, vlc_es_id_t *const es_id_list[])
Select multiple tracks from a list of ES identifiers.
Definition: player.c:447
void vlc_player_RemoveTimer(vlc_player_t *player, vlc_player_timer_id *timer)
Remove a player timer.
Definition: timer.c:452
Definition: player.h:49
void vlc_player_SetAssociatedSubsFPS(vlc_player_t *player, float fps)
Set the associated subtitle FPS.
Definition: player.c:1116
#define VLC_PLAYER_CAP_SEEK
Player capability: can seek.
Definition: vlc_player.h:358
void vlc_player_Pause(vlc_player_t *player)
Pause the playback.
Definition: player.c:1249
#define VLC_PLAYER_CAP_CHANGE_RATE
Player capability: can change the rate.
Definition: vlc_player.h:362
vlc_player_lock_type
Player lock type (normal or reentrant)
Definition: vlc_player.h:71
static void vlc_player_ToggleRecording(vlc_player_t *player)
Helper to toggle the recording state.
Definition: vlc_player.h:874
static const struct vlc_player_chapter * vlc_player_GetSelectedChapter(vlc_player_t *player)
Helper to get the current selected chapter.
Definition: vlc_player.h:1125
Definition: player.h:122
void vlc_player_SeekByTime(vlc_player_t *player, vlc_tick_t time, enum vlc_player_seek_speed speed, enum vlc_player_whence whence)
Seek the current media by time.
Definition: player.c:1435
Viewpoints.
Definition: vlc_viewpoint.h:41
bool vlc_player_vout_IsFullscreen(vlc_player_t *player)
Check if the player is fullscreen.
Definition: vout.c:101
Definition: vlc_es.h:603
The player is stopping.
Definition: vlc_player.h:281
static void vlc_player_SetPosition(vlc_player_t *player, float position)
Helper to set the absolute position precisely.
Definition: vlc_player.h:721
static void vlc_player_SelectAudioLanguage(vlc_player_t *player, const char *lang)
Helper to select the audio language.
Definition: vlc_player.h:1758
Definition: vlc_es.h:617
const struct vlc_player_track * vlc_player_GetTrackAt(vlc_player_t *player, enum es_format_category_e cat, size_t index)
Get the track at a specific index for an ES category.
Definition: player.c:368
void vlc_player_DecrementRate(vlc_player_t *player)
Decrement the rate of the player (Slower)
Definition: player.c:1355
float vlc_player_aout_GetVolume(vlc_player_t *player)
Get the audio volume.
Definition: aout.c:123
Player callbacks.
Definition: vlc_player.h:2612
static void vlc_player_UnselectTrack(vlc_player_t *player, const struct vlc_player_track *track)
Helper to unselect a track.
Definition: vlc_player.h:1657
int vlc_player_aout_SetVolume(vlc_player_t *player, float volume)
Set the audio volume.
Definition: aout.c:135
Select a navigation item on the right or move the viewpoint right.
Definition: vlc_player.h:340
Player chapter structure.
Definition: vlc_player.h:942
size_t count
Definition: core.c:402
Video output thread descriptor.
Definition: vlc_vout.h:60
void vlc_player_InvalidateNextMedia(vlc_player_t *player)
Invalidate the next media.
Definition: player.c:1135
void vlc_player_SelectNextChapter(vlc_player_t *player)
Select the next chapter for the current media.
Definition: player.c:929
vlc_player_title_list * vlc_player_title_list_Hold(vlc_player_title_list *titles)
Hold the title list of the player.
Definition: title.c:31
unsigned vlc_player_SelectEsId(vlc_player_t *player, vlc_es_id_t *es_id, enum vlc_player_select_policy policy)
Select a track from an ES identifier.
Definition: player.c:579
audio_output_t * vlc_player_aout_Hold(vlc_player_t *player)
Get the audio output.
Definition: aout.c:44
static const struct vlc_player_track * vlc_player_GetVideoTrackAt(vlc_player_t *player, size_t index)
Helper to get a video track at a specific index.
Definition: vlc_player.h:1405
void vlc_player_SelectPrevTrack(vlc_player_t *player, enum es_format_category_e cat)
Select the Previous track.
Definition: player.c:688
int vlc_player_GetSignal(vlc_player_t *player, float *quality, float *strength)
Get the signal quality and strength of the current media.
Definition: player.c:1794
#define VLC_PLAYER_CAP_REWIND
Player capability: can seek back.
Definition: vlc_player.h:364
vlc_player_timer_id * vlc_player_AddSmpteTimer(vlc_player_t *player, const struct vlc_player_timer_smpte_cbs *cbs, void *data)
Add a smpte timer in order to get accurate video frame updates.
Definition: timer.c:430
static const struct vlc_player_track * vlc_player_GetSubtitleTrackAt(vlc_player_t *player, size_t index)
Helper to get a subtitle track at a specific index.
Definition: vlc_player.h:1441
Player title structure.
Definition: vlc_player.h:956
void vlc_player_Unlock(vlc_player_t *player)
Unlock the player.
Definition: player.c:967
const struct vlc_player_title * vlc_player_title_list_GetAt(vlc_player_title_list *titles, size_t idx)
Get the title at a given index.
Definition: title.c:164
Opaque structure representing an ES (Elementary Stream) track.
Definition: es_out.c:92
bool vlc_player_IsRecording(vlc_player_t *player)
Check if the playing is recording.
Definition: player.c:1622
const char name[16]
Definition: httpd.c:1266
Reentrant lock.
Definition: vlc_player.h:88
struct vlc_player_track * vlc_player_track_Dup(const struct vlc_player_track *track)
Duplicate a track.
Definition: track.c:157
vlc_tick_t vlc_player_GetLength(vlc_player_t *player)
Get the length of the current media.
Definition: player.c:1361
vlc_tick_t vlc_player_GetTime(vlc_player_t *player)
Get the time of the current media.
Definition: player.c:1368
float vlc_player_GetAssociatedSubsFPS(vlc_player_t *player)
Get the associated subtitle FPS.
Definition: player.c:1128
Audio output modules interface.
vlc_vout_order
vout or spu_channel order
Definition: vlc_vout.h:78
vlc_player_vout_listener_id * vlc_player_vout_AddListener(vlc_player_t *player, const struct vlc_player_vout_cbs *cbs, void *cbs_data)
Add a listener callback for video output events.
Definition: vout.c:68
static void vlc_player_SetSubtitleDelay(vlc_player_t *player, vlc_tick_t delay, enum vlc_player_whence whence)
Helper to set the subtitle delay.
Definition: vlc_player.h:1985
Definition: vlc_player.h:381
Definition: vlc_player.h:2366
#define VLC_API
Definition: fourcc_gen.c:31
Audio output object.
Definition: vlc_aout.h:140
Condition variable.
Definition: vlc_threads.h:367
Definition: vlc_player.h:2593
vlc_es_id_t * vlc_player_GetEsIdFromVout(vlc_player_t *player, vout_thread_t *vout)
Get the ES identifier of a video output.
Definition: player.c:421
Select multiple tracks for one category.
Definition: vlc_player.h:1315
int vlc_player_SetCurrentMedia(vlc_player_t *player, input_item_t *media)
Set the current media.
Definition: player.c:1010
void vlc_player_SelectPrevTitle(vlc_player_t *player)
Select the previous title for the current media.
Definition: player.c:895
int group_id
Id used for vlc_player_SelectProgram()
Definition: vlc_player.h:1177
Definition: player.h:150
void vlc_player_RemoveListener(vlc_player_t *player, vlc_player_listener_id *listener_id)
Remove a listener callback.
Definition: player.c:999
input_item_t * vlc_player_GetCurrentMedia(vlc_player_t *player)
Get the current played media.
Definition: player.c:1053
vlc_player_t * vlc_player_New(vlc_object_t *parent, enum vlc_player_lock_type lock_type, const struct vlc_player_media_provider *media_provider, void *media_provider_data)
Create a new player instance.
Definition: player.c:1924
bool vlc_player_IsTeletextEnabled(vlc_player_t *player)
Check if teletext is enabled.
Definition: player.c:800
void vlc_player_UpdateViewpoint(vlc_player_t *player, const vlc_viewpoint_t *viewpoint, enum vlc_player_whence whence)
Update the viewpoint.
Definition: player.c:1604
vlc_object_t * vlc_player_GetV4l2Object(vlc_player_t *player)
Get the V4L2 object used to do controls.
Definition: player.c:1862
static void vlc_player_SetAudioDelay(vlc_player_t *player, vlc_tick_t delay, enum vlc_player_whence whence)
Helper to set the audio delay.
Definition: vlc_player.h:1965
void vlc_player_SelectPrevProgram(vlc_player_t *player)
Select the previous program.
Definition: player.c:349
Normal lock.
Definition: vlc_player.h:79
static const struct vlc_player_track * vlc_player_GetAudioTrackAt(vlc_player_t *player, size_t index)
Helper to get an audio track at a specific index.
Definition: vlc_player.h:1423
static void vlc_player_vout_ToggleFullscreen(vlc_player_t *player)
Helper to toggle the player fullscreen state.
Definition: vlc_player.h:2506
static void vlc_player_SelectSubtitleLanguage(vlc_player_t *player, const char *lang)
Helper to select the subtitle language.
Definition: vlc_player.h:1767
void vlc_player_CondWait(vlc_player_t *player, vlc_cond_t *cond)
Wait on a condition variable.
Definition: player.c:973
static size_t vlc_player_GetVideoTrackCount(vlc_player_t *player)
Helper to get the video track count.
Definition: vlc_player.h:1396
int vlc_player_aout_Mute(vlc_player_t *player, bool mute)
Mute or unmute the audio output.
Definition: aout.c:171
const struct vlc_player_program * vlc_player_GetProgramAt(vlc_player_t *player, size_t index)
Get the program at a specific index.
Definition: player.c:265
void vlc_player_SelectPrevChapter(vlc_player_t *player)
Select the previous chapter for the current media.
Definition: player.c:941
void vlc_player_UnselectEsId(vlc_player_t *player, vlc_es_id_t *es_id)
Unselect a track from an ES identifier.
Definition: player.c:695
size_t vlc_player_GetTrackCount(vlc_player_t *player, enum es_format_category_e cat)
Get the number of tracks for an ES category.
Definition: player.c:355
Do a fast seek.
Definition: vlc_player.h:306
vlc_player_state
State of the player.
Definition: vlc_player.h:243
Only one track per category is selected.
Definition: vlc_player.h:1307
static int vlc_player_aout_DecrementVolume(vlc_player_t *player, int steps, float *result)
Helper to decrement the audio volume.
Definition: vlc_player.h:2291
Definition: vlc_input_item.h:504
The current position +/- the given time/position.
Definition: vlc_player.h:321
The player is stopped.
Definition: vlc_player.h:251
void vlc_player_IncrementRate(vlc_player_t *player)
Increment the rate of the player (faster)
Definition: player.c:1349
Input thread interface.
Continue (or stop if there is no next media), default behavior.
Definition: vlc_player.h:98
void vlc_player_SelectNextTitle(vlc_player_t *player)
Select the next title for the current media.
Definition: player.c:883
void vlc_player_SetSubtitleTextScale(vlc_player_t *player, unsigned scale)
Set the subtitle text scaling factor.
Definition: player.c:1781
The player is playing.
Definition: vlc_player.h:266
static bool vlc_player_CanSeek(vlc_player_t *player)
Helper to get the seek capability.
Definition: vlc_player.h:573
void vlc_player_title_list_Release(vlc_player_title_list *titles)
Release of previously held title list.
Definition: title.c:38
static void vlc_player_SetAudioEnabled(vlc_player_t *player, bool enabled)
Helper to enable or disable audio tracks.
Definition: vlc_player.h:1818
Definition: vlc_player.h:2367
void vlc_player_RestorePlaybackPos(vlc_player_t *player)
Restore the previous playback position of the current media.
Definition: medialib.c:324
void vlc_player_Delete(vlc_player_t *player)
Delete a player instance.
Definition: player.c:1884
static unsigned vlc_player_SelectTrack(vlc_player_t *player, const struct vlc_player_track *track, enum vlc_player_select_policy policy)
Helper to select a track.
Definition: vlc_player.h:1570
bool vlc_player_IsTrackCategoryEnabled(vlc_player_t *player, enum es_format_category_e cat)
Check if a track category is enabled.
Definition: player.c:1773
vlc_player_vout_action
action of vlc_player_cbs.on_vout_changed callback
Definition: vlc_player.h:2364
static void vlc_player_SetPositionFast(vlc_player_t *player, float position)
Helper to set the absolute position fast.
Definition: vlc_player.h:731
bool vlc_player_IsTeletextTransparent(vlc_player_t *player)
Check if teletext is transparent.
Definition: player.c:819
static bool vlc_player_IsPaused(vlc_player_t *player)
Helper to get the paused state.
Definition: vlc_player.h:536
void vlc_player_Resume(vlc_player_t *player)
Resume the playback from a pause.
Definition: player.c:1255
VLC object common members.
Definition: vlc_objects.h:43
unsigned vlc_player_GetSubtitleTextScale(vlc_player_t *player)
Get the subtitle text scaling factor.
Definition: player.c:1788
size_t vlc_player_title_list_GetCount(vlc_player_title_list *titles)
Get the number of title of a list.
Definition: title.c:171
static int vlc_player_aout_ToggleMute(vlc_player_t *player)
Helper to toggle the mute state.
Definition: vlc_player.h:2330
static void vlc_player_SetVideoEnabled(vlc_player_t *player, bool enabled)
Helper to enable or disable video tracks.
Definition: vlc_player.h:1800
Select a navigation item under or move the viewpoint down.
Definition: vlc_player.h:336
bool selected
True if the track is selected.
Definition: vlc_player.h:1336
bool selected
True if the program is selected.
Definition: vlc_player.h:1181
static void vlc_player_vout_ToggleWallpaperMode(vlc_player_t *player)
Helper to toggle the player wallpaper-mode state.
Definition: vlc_player.h:2549
char * vlc_player_GetCategoryLanguage(vlc_player_t *player, enum es_format_category_e cat)
Get the language of an ES category.
Definition: player.c:736
void vlc_player_osd_Message(vlc_player_t *player, const char *fmt,...)
Display an OSD message on all vouts.
Definition: osd.c:88
ssize_t vlc_player_GetSelectedChapterIdx(vlc_player_t *player)
Get the selected chapter index for the current media.
Definition: player.c:907
int vlc_player_SetEsIdDelay(vlc_player_t *player, vlc_es_id_t *es_id, vlc_tick_t delay, enum vlc_player_whence whence)
Set the delay of one track.
Definition: player.c:1692
void vlc_player_SelectTracksByStringIds(vlc_player_t *player, enum es_format_category_e cat, const char *str_ids)
Select tracks by their string identifier.
Definition: player.c:606
vlc_player_aout_listener_id * vlc_player_aout_AddListener(vlc_player_t *player, const struct vlc_player_aout_cbs *cbs, void *cbs_data)
Add a listener callback for audio output events.
Definition: aout.c:50
int vlc_player_SetCategoryDelay(vlc_player_t *player, enum es_format_category_e cat, vlc_tick_t delay, enum vlc_player_whence whence)
Set the delay of one category for the current media.
Definition: player.c:1645
input_item_t * input_item_Hold(input_item_t *p_item)
Holds an input item, i.e.
Definition: item.c:468
vout_thread_t * vlc_player_GetEsIdVout(vlc_player_t *player, vlc_es_id_t *es_id, enum vlc_vout_order *order)
Get and the video output used by a ES identifier.
Definition: player.c:406
float vlc_player_GetPosition(vlc_player_t *player)
Get the position of the current media.
Definition: player.c:1379
Callbacks for the owner of the player.
Definition: vlc_player.h:117
struct vlc_player_program * vlc_player_program_Dup(const struct vlc_player_program *prgm)
Duplicate a program.
Definition: track.c:69
vlc_player_listener_id * vlc_player_AddListener(vlc_player_t *player, const struct vlc_player_cbs *cbs, void *cbs_data)
Add a listener callback.
Definition: player.c:980
static const struct vlc_player_title * vlc_player_GetSelectedTitle(vlc_player_t *player)
Helper to get the current selected title.
Definition: vlc_player.h:1038
Definition: vlc_player.h:2594
bool vlc_player_HasTeletextMenu(vlc_player_t *player)
Check if the media has a teletext menu.
Definition: player.c:793
void vlc_player_Navigate(vlc_player_t *player, enum vlc_player_nav nav)
Navigate (for DVD/Bluray menus or viewpoint)
Definition: player.c:1566
vlc_player_title_list * vlc_player_GetTitleList(vlc_player_t *player)
Get the title list of the current media.
Definition: player.c:826
void vlc_player_SetRecordingEnabled(vlc_player_t *player, bool enabled)
Enable or disable recording for the current media.
Definition: player.c:1630
void vlc_player_SetPauseOnCork(vlc_player_t *player, bool enabled)
Enable or disable pause on cork event.
Definition: player.c:1817
Select a navigation item on the left or move the viewpoint left.
Definition: vlc_player.h:338
Definition: vlc_player.h:354
ssize_t vlc_player_GetSelectedTitleIdx(vlc_player_t *player)
Get the selected title index for the current media.
Definition: player.c:833
void vlc_player_vout_SetWallpaperModeEnabled(vlc_player_t *player, bool enabled)
Enable or disable the player wallpaper-mode.
Definition: vout.c:198