videolan
/
vlc
mirror of https://code.videolan.org/videolan/vlc
1
Fork 0
Code Releases Activity

player: move SetMediaStoppedAction() to the playlist 

The playlist is more suited to handle what to do after a playback.

This will allow to simplify the vlc_player_t media provider by removing
its callback that was sent depending on the media_stopped_action.

Thanks to Pierre for the Qt part of this commit.

Co-authored-by: Pierre Lamot <pierre@videolabs.io>

Related to #28524
This commit is contained in:
Thomas Guillem 2024-02-28 16:49:31 +01:00
parent ccfd7ccc57
commit 3657a5376a
23 changed files with 175 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
include/vlc_player.h
View File

@ -87,22 +87,6 @@ enum vlc_player_lock_type
VLC_PLAYER_LOCK_REENTRANT,
};
/**
* Action when the player is stopped
*
* @see vlc_player_SetMediaStoppedAction()
*/
enum vlc_player_media_stopped_action {
/** Continue (or stop if there is no next media), default behavior */
VLC_PLAYER_MEDIA_STOPPED_CONTINUE,
/** Pause when reaching the end of file */
VLC_PLAYER_MEDIA_STOPPED_PAUSE,
/** Stop, even if there is a next media to play */
VLC_PLAYER_MEDIA_STOPPED_STOP,
/** Exit VLC */
VLC_PLAYER_MEDIA_STOPPED_EXIT,
};
/**
* Callbacks for the owner of the player.
*
@ -186,16 +170,6 @@ vlc_player_Unlock(vlc_player_t *player);
VLC_API void
vlc_player_CondWait(vlc_player_t *player, vlc_cond_t *cond);
/**
* Setup an action when a media is stopped
*
* @param player locked player instance
* @param action action to do when a media is stopped
*/
VLC_API void
vlc_player_SetMediaStoppedAction(vlc_player_t *player,
enum vlc_player_media_stopped_action action);
/**
* Ask to start in a paused state
*
@ -3143,18 +3117,6 @@ struct vlc_player_cbs
enum vlc_player_abloop new_state, vlc_tick_t time, double pos,
void *data);
/**
* Called when media stopped action has changed
*
* @see vlc_player_SetMediaStoppedAction()
*
* @param player locked player instance
* @param new_action action to execute when a media is stopped
* @param data opaque pointer set by vlc_player_AddListener()
*/
void (*on_media_stopped_action_changed)(vlc_player_t *player,
enum vlc_player_media_stopped_action new_action, void *data);
/**
* Called when the media meta and/or info has changed
*

39
include/vlc_playlist.h
View File

@ -154,6 +154,22 @@ struct vlc_playlist_sort_criterion
enum vlc_playlist_sort_order order;
};
/**
* Action when a media is stopped
*
* @see vlc_playlist_SetMediaStoppedAction()
*/
enum vlc_playlist_media_stopped_action {
/** Continue (or stop if there is no next media), default behavior */
VLC_PLAYLIST_MEDIA_STOPPED_CONTINUE,
/** Pause when reaching the end of file */
VLC_PLAYLIST_MEDIA_STOPPED_PAUSE,
/** Stop, even if there is a next media to play */
VLC_PLAYLIST_MEDIA_STOPPED_STOP,
/** Exit VLC */
VLC_PLAYLIST_MEDIA_STOPPED_EXIT,
};
/**
* Playlist callbacks.
*
@ -292,6 +308,19 @@ struct vlc_playlist_callbacks
void
(*on_has_next_changed)(vlc_playlist_t *playlist,
bool has_next, void *userdata);
/**
* Called when the stopped action has changed
*
* @see vlc_playlist_SetMediaStoppedAction()
*
* \param playlist the playlist
* @param new_action action to execute when a media is stopped
* \param userdata userdata provided to AddListener()
*/
void (*on_media_stopped_action_changed)(vlc_playlist_t *playlist,
enum vlc_playlist_media_stopped_action new_action,
void *userdata);
};
/* Playlist items */
@ -401,6 +430,16 @@ VLC_API void
vlc_playlist_RemoveListener(vlc_playlist_t *playlist,
vlc_playlist_listener_id *id);
/**
* Setup an action when a media is stopped
*
* @param playlist the playlist, locked
* @param action action to do when a media is stopped
*/
VLC_API void
vlc_playlist_SetMediaStoppedAction(vlc_playlist_t *playlist,
enum vlc_playlist_media_stopped_action action);
/**
* Return the number of items.
*

8
modules/gui/macosx/menus/VLCMainMenu.m
View File

@ -890,10 +890,10 @@ typedef NS_ENUM(NSInteger, VLCObjectType) {
- (IBAction)quitAfterPlayback:(id)sender
{
if (_playerController.actionAfterStop != VLC_PLAYER_MEDIA_STOPPED_EXIT) {
_playerController.actionAfterStop = VLC_PLAYER_MEDIA_STOPPED_EXIT;
if (_playlistController.actionAfterStop != VLC_PLAYLIST_MEDIA_STOPPED_EXIT) {
_playlistController.actionAfterStop = VLC_PLAYLIST_MEDIA_STOPPED_EXIT;
} else {
_playerController.actionAfterStop = VLC_PLAYER_MEDIA_STOPPED_CONTINUE;
_playlistController.actionAfterStop = VLC_PLAYLIST_MEDIA_STOPPED_CONTINUE;
}
}
@ -1964,7 +1964,7 @@ typedef NS_ENUM(NSInteger, VLCObjectType) {
enum vlc_playlist_playback_order playbackOrder = [_playlistController playbackOrder];
[mi setState: playbackOrder == VLC_PLAYLIST_PLAYBACK_ORDER_RANDOM ? NSOnState : NSOffState];
} else if (mi == _quitAfterPB) {
BOOL state = _playerController.actionAfterStop == VLC_PLAYER_MEDIA_STOPPED_EXIT;
BOOL state = _playlistController.actionAfterStop == VLC_PLAYLIST_MEDIA_STOPPED_EXIT;
[mi setState: state ? NSOnState : NSOffState];
} else if (mi == _fwd || mi == _bwd || mi == _jumpToTime) {
enabled = _playerController.seekable;

7
modules/gui/macosx/playlist/VLCPlayerController.h
View File

@ -298,13 +298,6 @@ extern const CGFloat VLCVolumeDefault;
*/
- (int)disableABLoop;
/**
* Define the action to perform after playback of the current media stopped (for any reason)
* Options are: continue with next time, pause on last frame, stop even if there is a next item and quit VLC
* @see the vlc_player_media_stopped_action enum for details
*/
@property (readwrite, nonatomic) enum vlc_player_media_stopped_action actionAfterStop;
/**
* Move on to the next video frame and pause
* @warning this relies on a gross hack in the core and will work for 20 consecutive frames maximum only

25
modules/gui/macosx/playlist/VLCPlayerController.m
View File

@ -129,7 +129,6 @@ const CGFloat VLCVolumeDefault = 1.;
- (void)programListChanged;
- (void)programSelectionChanged:(int)selectedID;
- (void)ABLoopStateChanged:(enum vlc_player_abloop)abLoopState;
- (void)stopActionChanged:(enum vlc_player_media_stopped_action)stoppedAction;
- (void)metaDataChangedForInput:(input_item_t *)inputItem;
- (void)voutListUpdated;
@ -430,17 +429,6 @@ static void cb_player_atobloop_changed(vlc_player_t *p_player,
});
}
static void cb_player_media_stopped_action_changed(vlc_player_t *p_player,
enum vlc_player_media_stopped_action newAction,
void *p_data)
{
VLC_UNUSED(p_player);
dispatch_async(dispatch_get_main_queue(), ^{
VLCPlayerController *playerController = (__bridge VLCPlayerController *)p_data;
[playerController stopActionChanged:newAction];
});
}
static void cb_player_item_meta_changed(vlc_player_t *p_player,
input_item_t *p_mediaItem,
void *p_data)
@ -501,7 +489,6 @@ static const struct vlc_player_cbs player_callbacks = {
.on_signal_changed = NULL,
.on_statistics_changed = cb_player_stats_changed,
.on_atobloop_changed = cb_player_atobloop_changed,
.on_media_stopped_action_changed = cb_player_media_stopped_action_changed,
.on_media_meta_changed = cb_player_item_meta_changed,
.on_media_epg_changed = NULL,
.on_media_subitems_changed = NULL,
@ -725,18 +712,6 @@ static int BossCallback(vlc_object_t *p_this,
vlc_player_Unlock(_p_player);
}
- (void)stopActionChanged:(enum vlc_player_media_stopped_action)stoppedAction
{
_actionAfterStop = stoppedAction;
}
- (void)setActionAfterStop:(enum vlc_player_media_stopped_action)actionAfterStop
{
vlc_player_Lock(_p_player);
vlc_player_SetMediaStoppedAction(_p_player, actionAfterStop);
vlc_player_Unlock(_p_player);
}
- (void)metaDataChangedForInput:(input_item_t *)inputItem
{
[_defaultNotificationCenter postNotificationName:VLCPlayerMetadataChangedForCurrentMedia

8
modules/gui/macosx/playlist/VLCPlaylistController.h
View File

@ -106,6 +106,14 @@ extern NSString *VLCPlaylistItemsRemoved;
@property (readwrite) BOOL libraryPlaylistMode;
/**
* Define the action to perform after playback of the current media stopped (for any reason)
* Options are: continue with next time, pause on last frame, stop even if there is a next item and quit VLC
* @see the vlc_playlist_media_stopped_action enum for details
*/
@property (readwrite, nonatomic) enum vlc_playlist_media_stopped_action actionAfterStop;
/**
* Simplified version to add new items to the end of the current playlist
* @param array array of items. Each item is an instance of VLCOpenInputMetadata.

26
modules/gui/macosx/playlist/VLCPlaylistController.m
View File

@ -60,6 +60,7 @@ NSString *VLCPlaylistItemsRemoved = @"VLCPlaylistItemsRemoved";
- (void)currentPlaylistItemIndexChanged:(size_t)index;
- (void)playlistHasPreviousItem:(BOOL)hasPrevious;
- (void)playlistHasNextItem:(BOOL)hasNext;
- (void)stopActionChanged:(enum vlc_playlist_media_stopped_action)stoppedAction;
@end
@ -194,6 +195,18 @@ cb_playlist_has_next_changed(vlc_playlist_t *playlist,
});
}
static void
cb_playlist_media_stopped_action_changed(vlc_playlist_t *p_playlist,
enum vlc_playlist_media_stopped_action newAction,
void *p_data)
{
VLC_UNUSED(p_playlist);
dispatch_async(dispatch_get_main_queue(), ^{
VLCPlaylistController *playlistController = (__bridge VLCPlaylistController *)p_data;
[playlistController stopActionChanged:newAction];
});
}
static const struct vlc_playlist_callbacks playlist_callbacks = {
cb_playlist_items_reset,
cb_playlist_items_added,
@ -205,6 +218,7 @@ static const struct vlc_playlist_callbacks playlist_callbacks = {
cb_playlist_current_item_index_changed,
cb_playlist_has_prev_changed,
cb_playlist_has_next_changed,
cb_playlist_media_stopped_action_changed,
};
#pragma mark -
@ -690,6 +704,18 @@ static const struct vlc_playlist_callbacks playlist_callbacks = {
return ret;
}
- (void)stopActionChanged:(enum vlc_playlist_media_stopped_action)stoppedAction
{
_actionAfterStop = stoppedAction;
}
- (void)setActionAfterStop:(enum vlc_playlist_media_stopped_action)actionAfterStop
{
vlc_playlist_Lock(_p_playlist);
vlc_playlist_SetMediaStoppedAction(_p_playlist, actionAfterStop);
vlc_playlist_Unlock(_p_playlist);
}
@end
@implementation VLCPlaylistExportModuleDescription

10
modules/gui/qt/menus/menus.cpp
View File

@ -215,10 +215,14 @@ void VLCMenuBar::FileMenu(qt_intf_t *p_intf, QMenu *menu)
":/menu/stream.svg", &DialogsProvider::openAndStreamingDialogs, "Ctrl+S" );
menu->addSeparator();
action = addMPLStaticEntry( p_intf, menu, qtr( "Quit at the end of playlist" ), "",
&PlaylistController::playAndExitChanged );
action = menu->addAction( qtr( "Quit at the end of playlist" ), [playlist = THEMPL](bool checked){
if (checked)
playlist->setMediaStopAction(PlaylistController::MEDIA_STOPPED_EXIT);
else
playlist->setMediaStopAction(PlaylistController::MEDIA_STOPPED_CONTINUE);
});
action->setCheckable( true );
action->setChecked( THEMPL->isPlayAndExit() );
action->setChecked( THEMPL->getMediaStopAction() == PlaylistController::MEDIA_STOPPED_EXIT);
if( mi && mi->getSysTray() )
{

18
modules/gui/qt/player/player_controller.cpp
View File

@ -746,15 +746,6 @@ static void on_player_atobloop_changed(vlc_player_t *, enum vlc_player_abloop st
});
}
static void on_player_media_stopped_action_changed(vlc_player_t *, enum vlc_player_media_stopped_action new_action, void *data)
{
PlayerControllerPrivate* that = static_cast<PlayerControllerPrivate*>(data);
that->callAsync([that,new_action] () {
that->m_mediaStopAction = static_cast<PlayerController::MediaStopAction>(new_action);
emit that->q_func()->mediaStopActionChanged(that->m_mediaStopAction);
});
}
static void on_player_media_meta_changed(vlc_player_t *, input_item_t *media, void *data)
{
PlayerControllerPrivate* that = static_cast<PlayerControllerPrivate*>(data);
@ -1049,7 +1040,6 @@ static const struct vlc_player_cbs player_cbs = {
on_player_signal_changed,
on_player_stats_changed,
on_player_atobloop_changed,
on_player_media_stopped_action_changed,
on_player_media_meta_changed,
on_player_media_epg_changed,
on_player_subitems_changed,
@ -1207,13 +1197,6 @@ void PlayerController::setRate( float new_rate )
vlc_player_ChangeRate( d->m_player, new_rate );
}
void PlayerController::setMediaStopAction(PlayerController::MediaStopAction action)
{
Q_D(PlayerController);
vlc_player_locker lock{ d->m_player };
vlc_player_SetMediaStoppedAction( d->m_player, static_cast<vlc_player_media_stopped_action>(action) );
}
void PlayerController::slower()
{
Q_D(PlayerController);
@ -2091,7 +2074,6 @@ PRIMITIVETYPE_GETTER(bool, canRestorePlayback, m_canRestorePlayback);
PRIMITIVETYPE_GETTER(float, getSubtitleFPS, m_subtitleFPS)
PRIMITIVETYPE_GETTER(bool, hasVideoOutput, m_hasVideo)
PRIMITIVETYPE_GETTER(float, getBuffering, m_buffering)
PRIMITIVETYPE_GETTER(PlayerController::MediaStopAction, getMediaStopAction, m_mediaStopAction)
PRIMITIVETYPE_GETTER(float, getVolume, m_volume)
PRIMITIVETYPE_GETTER(bool, isMuted, m_muted)
PRIMITIVETYPE_GETTER(bool, isFullscreen, m_fullscreen)

13
modules/gui/qt/player/player_controller.hpp
View File

@ -95,15 +95,6 @@ public:
};
Q_ENUM(PlayingState)
enum MediaStopAction
{
MEDIA_STOPPED_CONTINUE = VLC_PLAYER_MEDIA_STOPPED_CONTINUE,
MEDIA_STOPPED_PAUSE = VLC_PLAYER_MEDIA_STOPPED_PAUSE,
MEDIA_STOPPED_STOP = VLC_PLAYER_MEDIA_STOPPED_STOP,
MEDIA_STOPPED_EXIT = VLC_PLAYER_MEDIA_STOPPED_EXIT
};
Q_ENUM(MediaStopAction)
enum Telekeys{
TELE_RED = VLC_PLAYER_TELETEXT_KEY_RED,
TELE_GREEN = VLC_PLAYER_TELETEXT_KEY_GREEN,
@ -119,7 +110,6 @@ public:
Q_PROPERTY(QString name READ getName NOTIFY nameChanged FINAL)
Q_PROPERTY(float buffering READ getBuffering NOTIFY bufferingChanged FINAL)
Q_PROPERTY(float rate READ getRate WRITE setRate NOTIFY rateChanged FINAL)
Q_PROPERTY(MediaStopAction mediaStopAction READ getMediaStopAction WRITE setMediaStopAction NOTIFY mediaStopActionChanged FINAL)
Q_PROPERTY(VLCTick time READ getTime WRITE setTime NOTIFY timeChanged FINAL)
Q_PROPERTY(VLCTick remainingTime READ getRemainingTime NOTIFY remainingTimeChanged FINAL)
@ -289,8 +279,6 @@ public slots:
float getBuffering() const;
float getRate() const;
void setRate( float );
MediaStopAction getMediaStopAction() const;
void setMediaStopAction(MediaStopAction );
VLCTick getTime() const;
void setTime(VLCTick);
VLCTick getRemainingTime() const;
@ -408,7 +396,6 @@ signals:
void nameChanged( const QString& );
void bufferingChanged( float );
void rateChanged( float );
void mediaStopActionChanged( MediaStopAction );
void timeChanged( VLCTick );
void remainingTimeChanged( VLCTick );

1
modules/gui/qt/player/player_controller_p.hpp
View File

@ -76,7 +76,6 @@ public:
QString m_name;
float m_buffering = 0.f;
float m_rate = 1.f;
PlayerController::MediaStopAction m_mediaStopAction = PlayerController::MEDIA_STOPPED_CONTINUE;
VLCTick m_time = 0;
VLCTick m_remainingTime = 0;

28
modules/gui/qt/playlist/playlist_controller.cpp
View File

@ -303,6 +303,23 @@ on_playlist_has_next_changed(vlc_playlist_t *playlist, bool has_next,
});
}
static void
on_media_stopped_action_changed(vlc_playlist_t *playlist,
enum vlc_playlist_media_stopped_action new_action,
void *userdata)
{
PlaylistControllerPrivate *that = static_cast<PlaylistControllerPrivate *>(userdata);
that->callAsync([=](){
auto action = static_cast<PlaylistController::MediaStopAction>(new_action);
if (that->m_playlist != playlist)
return;
if (that->m_mediaStopAction == action)
return;
that->m_mediaStopAction = action;
emit that->q_func()->mediaStopActionChanged(action);
});
}
} // extern "C"
static const struct vlc_playlist_callbacks playlist_callbacks = []{
@ -317,6 +334,7 @@ static const struct vlc_playlist_callbacks playlist_callbacks = []{
cbs.on_current_index_changed = on_playlist_current_item_changed;
cbs.on_has_next_changed = on_playlist_has_next_changed;
cbs.on_has_prev_changed = on_playlist_has_prev_changed;
cbs.on_media_stopped_action_changed = on_media_stopped_action_changed;
return cbs;
}();
@ -729,19 +747,17 @@ void PlaylistController::setRepeatMode(PlaylistController::PlaybackRepeat mode)
vlc_playlist_SetPlaybackRepeat( d->m_playlist, static_cast<vlc_playlist_playback_repeat>(mode) );
}
bool PlaylistController::isPlayAndExit() const
PlaylistController::MediaStopAction PlaylistController::getMediaStopAction() const
{
Q_D(const PlaylistController);
return d->m_isPlayAndExit;
return d->m_mediaStopAction;
}
void PlaylistController::setPlayAndExit(bool enable)
void PlaylistController::setMediaStopAction(PlaylistController::MediaStopAction action)
{
Q_D(PlaylistController);
vlc_playlist_locker lock{ d->m_playlist };
vlc_player_t* player = vlc_playlist_GetPlayer( d->m_playlist );
vlc_player_SetMediaStoppedAction( player, enable ? VLC_PLAYER_MEDIA_STOPPED_EXIT : VLC_PLAYER_MEDIA_STOPPED_CONTINUE );
vlc_playlist_SetMediaStoppedAction(d->m_playlist, static_cast<vlc_playlist_media_stopped_action>(action) );
}
bool PlaylistController::isEmpty() const

20
modules/gui/qt/playlist/playlist_controller.hpp
View File

@ -81,6 +81,15 @@ public:
};
Q_ENUM(SortOrder)
enum MediaStopAction
{
MEDIA_STOPPED_CONTINUE = VLC_PLAYLIST_MEDIA_STOPPED_CONTINUE,
MEDIA_STOPPED_PAUSE = VLC_PLAYLIST_MEDIA_STOPPED_PAUSE,
MEDIA_STOPPED_STOP = VLC_PLAYLIST_MEDIA_STOPPED_STOP,
MEDIA_STOPPED_EXIT = VLC_PLAYLIST_MEDIA_STOPPED_EXIT
};
Q_ENUM(MediaStopAction)
Q_PROPERTY(QVariantList sortKeyTitleList READ getSortKeyTitleList CONSTANT FINAL)
Q_PROPERTY(Playlist playlist READ getPlaylist WRITE setPlaylist NOTIFY playlistChanged FINAL)
@ -91,11 +100,12 @@ public:
Q_PROPERTY(bool hasPrev READ hasPrev NOTIFY hasPrevChanged FINAL)
Q_PROPERTY(bool random READ isRandom WRITE setRandom NOTIFY randomChanged FINAL)
Q_PROPERTY(PlaybackRepeat repeatMode READ getRepeatMode WRITE setRepeatMode NOTIFY repeatModeChanged FINAL)
Q_PROPERTY(bool playAndExit READ isPlayAndExit WRITE setPlayAndExit NOTIFY playAndExitChanged FINAL)
Q_PROPERTY(bool empty READ isEmpty NOTIFY isEmptyChanged FINAL)
Q_PROPERTY(int count READ count NOTIFY countChanged FINAL)
Q_PROPERTY(SortKey sortKey READ getSortKey WRITE setSortKey NOTIFY sortKeyChanged FINAL)
Q_PROPERTY(SortOrder sortOrder READ getSortOrder WRITE setSortOrder NOTIFY sortOrderChanged FINAL)
Q_PROPERTY(MediaStopAction mediaStopAction READ getMediaStopAction WRITE setMediaStopAction NOTIFY mediaStopActionChanged FINAL)
public:
Q_INVOKABLE void play();
@ -144,12 +154,12 @@ public slots:
bool isRandom() const;
void setRandom( bool );
MediaStopAction getMediaStopAction() const;
void setMediaStopAction(MediaStopAction );
PlaybackRepeat getRepeatMode() const;
void setRepeatMode( PlaybackRepeat mode );
bool isPlayAndExit() const;
void setPlayAndExit(bool );
bool isEmpty() const;
int count() const;
@ -174,7 +184,7 @@ signals:
void hasNextChanged( bool );
void hasPrevChanged( bool );
void randomChanged( bool );
void playAndExitChanged( bool );
void mediaStopActionChanged( MediaStopAction );
void repeatModeChanged( PlaybackRepeat );
void isEmptyChanged( bool empty );
void countChanged(int);

2
modules/gui/qt/playlist/playlist_controller_p.hpp
View File

@ -55,7 +55,7 @@ public:
bool m_hasPrev = false;
PlaylistController::PlaybackRepeat m_repeat = PlaylistController::PLAYBACK_REPEAT_NONE;
bool m_random = false;
bool m_isPlayAndExit = false;
PlaylistController::MediaStopAction m_mediaStopAction = PlaylistController::MEDIA_STOPPED_CONTINUE;
bool m_empty = true;
size_t m_count = 0;
PlaylistController::SortKey m_sortKey = PlaylistController::SORT_KEY_NONE;

12
src/interface/interface.c
View File

@ -68,15 +68,15 @@ PlaylistConfigureFromVariables(vlc_playlist_t *playlist, vlc_object_t *obj)
else
repeat = VLC_PLAYLIST_PLAYBACK_REPEAT_NONE;
enum vlc_player_media_stopped_action media_stopped_action;
enum vlc_playlist_media_stopped_action media_stopped_action;
if (var_InheritBool(obj, "play-and-exit"))
media_stopped_action = VLC_PLAYER_MEDIA_STOPPED_EXIT;
media_stopped_action = VLC_PLAYLIST_MEDIA_STOPPED_EXIT;
else if (var_InheritBool(obj, "play-and-stop"))
media_stopped_action = VLC_PLAYER_MEDIA_STOPPED_STOP;
media_stopped_action = VLC_PLAYLIST_MEDIA_STOPPED_STOP;
else if (var_InheritBool(obj, "play-and-pause"))
media_stopped_action = VLC_PLAYER_MEDIA_STOPPED_PAUSE;
media_stopped_action = VLC_PLAYLIST_MEDIA_STOPPED_PAUSE;
else
media_stopped_action = VLC_PLAYER_MEDIA_STOPPED_CONTINUE;
media_stopped_action = VLC_PLAYLIST_MEDIA_STOPPED_CONTINUE;
bool start_paused = var_InheritBool(obj, "start-paused");
bool playlist_cork = var_InheritBool(obj, "playlist-cork");
@ -84,12 +84,12 @@ PlaylistConfigureFromVariables(vlc_playlist_t *playlist, vlc_object_t *obj)
vlc_playlist_Lock(playlist);
vlc_playlist_SetPlaybackOrder(playlist, order);
vlc_playlist_SetPlaybackRepeat(playlist, repeat);
vlc_playlist_SetMediaStoppedAction(playlist, media_stopped_action);
vlc_player_t *player = vlc_playlist_GetPlayer(playlist);
/* the playlist and the player share the same lock, and this is not an
* implementation detail */
vlc_player_SetMediaStoppedAction(player, media_stopped_action);
vlc_player_SetStartPaused(player, start_paused);
vlc_player_SetPauseOnCork(player, playlist_cork);

2
src/libvlccore.sym
View File

@ -932,7 +932,6 @@ vlc_player_SetAtoBLoop
vlc_player_SetCategoryDelay
vlc_player_SetCurrentMedia
vlc_player_SetEsIdDelay
vlc_player_SetMediaStoppedAction
vlc_player_SetRecordingEnabled
vlc_player_SetRenderer
vlc_player_SetStartPaused
@ -1006,6 +1005,7 @@ vlc_playlist_Pause
vlc_playlist_Resume
vlc_playlist_Preparse
vlc_playlist_Export
vlc_playlist_SetMediaStoppedAction
vlc_intf_GetMainPlaylist
vlc_media_source_Hold
vlc_media_source_Release

30
src/player/input.c
View File

@ -23,7 +23,6 @@
#endif
#include <vlc_common.h>
#include <vlc_interface.h>
#include <vlc_memstream.h>
#include "player.h"
@ -222,7 +221,6 @@ vlc_player_input_HandleState(struct vlc_player_input *input,
&& state != VLC_PLAYER_STATE_STOPPED)
return;
enum vlc_player_state last_state = input->state;
input->state = state;
/* Override the global state if the player is still playing and has a next
@ -258,34 +256,14 @@ vlc_player_input_HandleState(struct vlc_player_input *input,
player->last_eos = vlc_tick_now();
if (!player->deleting)
{
vlc_player_OpenNextMedia(player);
if (player->input)
vlc_player_input_Start(player->input);
}
if (!player->input)
player->started = false;
/* If the last input was not even started, always play the next
* media */
enum vlc_player_media_stopped_action stopped_action;
if (last_state == VLC_PLAYER_STATE_STOPPED)
stopped_action = VLC_PLAYER_MEDIA_STOPPED_CONTINUE;
else
stopped_action = player->media_stopped_action;
switch (stopped_action)
{
case VLC_PLAYER_MEDIA_STOPPED_EXIT:
if (player->input && player->started)
vlc_player_input_Start(player->input);
else
libvlc_Quit(vlc_object_instance(player));
break;
case VLC_PLAYER_MEDIA_STOPPED_CONTINUE:
if (player->input && player->started)
vlc_player_input_Start(player->input);
break;
default:
break;
}
send_event = !player->started;
break;
case VLC_PLAYER_STATE_STOPPING:

13
src/player/player.c
View File

@ -57,7 +57,6 @@ vlc_player_PrepareNextMedia(vlc_player_t *player)
vlc_player_assert_locked(player);
if (!player->media_provider
|| player->media_stopped_action == VLC_PLAYER_MEDIA_STOPPED_STOP
|| player->next_media_requested)
return;
@ -1217,17 +1216,6 @@ vlc_player_Stop(vlc_player_t *player)
return VLC_SUCCESS;
}
void
vlc_player_SetMediaStoppedAction(vlc_player_t *player,
enum vlc_player_media_stopped_action action)
{
vlc_player_assert_locked(player);
player->media_stopped_action = action;
var_SetBool(player, "play-and-pause",
action == VLC_PLAYER_MEDIA_STOPPED_PAUSE);
vlc_player_SendEvent(player, on_media_stopped_action_changed, action);
}
void
vlc_player_SetStartPaused(vlc_player_t *player, bool start_paused)
{
@ -1921,7 +1909,6 @@ vlc_player_New(vlc_object_t *parent, enum vlc_player_lock_type lock_type,
vlc_list_init(&player->destructor.inputs);
vlc_list_init(&player->destructor.stopping_inputs);
vlc_list_init(&player->destructor.joinable_inputs);
player->media_stopped_action = VLC_PLAYER_MEDIA_STOPPED_CONTINUE;
player->start_paused = false;
player->pause_on_cork = false;
player->corked = false;

1
src/player/player.h
View File

@ -239,7 +239,6 @@ struct vlc_player_t
vlc_mutex_t vout_listeners_lock;
vlc_cond_t start_delay_cond;
enum vlc_player_media_stopped_action media_stopped_action;
bool start_paused;
const struct vlc_player_media_provider *media_provider;

2
src/playlist/notify.c
View File

@ -43,6 +43,8 @@ vlc_playlist_NotifyCurrentState(vlc_playlist_t *playlist,
playlist->has_prev);
vlc_playlist_NotifyListener(playlist, listener, on_has_next_changed,
playlist->has_next);
vlc_playlist_NotifyListener(playlist, listener, on_media_stopped_action_changed,
playlist->stopped_action);
}
vlc_playlist_listener_id *

39
src/playlist/player.c
View File

@ -22,6 +22,9 @@
# include "config.h"
#endif
#include <vlc_common.h>
#include <vlc_interface.h>
#include "player.h"
#include "../player/player.h"
@ -72,6 +75,17 @@ player_on_current_media_changed(vlc_player_t *player, input_item_t *new_media,
vlc_playlist_state_NotifyChanges(playlist, &state);
}
static void
on_player_state_changed(vlc_player_t *player,
enum vlc_player_state new_state, void *userdata)
{
vlc_playlist_t *playlist = userdata;
if (new_state == VLC_PLAYER_STATE_STOPPED
&& playlist->stopped_action == VLC_PLAYLIST_MEDIA_STOPPED_EXIT)
libvlc_Quit(vlc_object_instance(player));
}
static void
on_player_media_meta_changed(vlc_player_t *player, input_item_t *media,
void *userdata)
@ -117,7 +131,17 @@ player_get_next_media(vlc_player_t *player, void *userdata)
{
VLC_UNUSED(player);
vlc_playlist_t *playlist = userdata;
return vlc_playlist_GetNextMedia(playlist);
switch (playlist->stopped_action)
{
case VLC_PLAYLIST_MEDIA_STOPPED_CONTINUE:
case VLC_PLAYLIST_MEDIA_STOPPED_PAUSE:
case VLC_PLAYLIST_MEDIA_STOPPED_EXIT:
return vlc_playlist_GetNextMedia(playlist);
case VLC_PLAYLIST_MEDIA_STOPPED_STOP:
return NULL;
default:
vlc_assert_unreachable();
}
}
static const struct vlc_player_media_provider player_media_provider = {
@ -126,6 +150,7 @@ static const struct vlc_player_media_provider player_media_provider = {
static const struct vlc_player_cbs player_callbacks = {
.on_current_media_changed = player_on_current_media_changed,
.on_state_changed = on_player_state_changed,
.on_media_meta_changed = on_player_media_meta_changed,
.on_length_changed = on_player_media_length_changed,
.on_media_subitems_changed = on_player_media_subitems_changed,
@ -193,3 +218,15 @@ vlc_playlist_Resume(vlc_playlist_t *playlist)
{
vlc_player_Resume(playlist->player);
}
void
vlc_playlist_SetMediaStoppedAction(vlc_playlist_t *playlist,
enum vlc_playlist_media_stopped_action action)
{
vlc_playlist_AssertLocked(playlist);
playlist->stopped_action = action;
var_SetBool(playlist->player, "play-and-pause",
action == VLC_PLAYLIST_MEDIA_STOPPED_PAUSE);
vlc_player_InvalidateNextMedia(playlist->player);
vlc_playlist_Notify(playlist, on_media_stopped_action_changed, action);
}

1
src/playlist/playlist.c
View File

@ -43,6 +43,7 @@ vlc_playlist_New(vlc_object_t *parent)
free(playlist);
return NULL;
}
playlist->stopped_action = VLC_PLAYLIST_MEDIA_STOPPED_CONTINUE;
vlc_vector_init(&playlist->items);
randomizer_Init(&playlist->randomizer);

1
src/playlist/playlist.h
View File

@ -49,6 +49,7 @@ struct vlc_playlist
{
vlc_player_t *player;
libvlc_int_t *libvlc;
enum vlc_playlist_media_stopped_action stopped_action;
bool auto_preparse;
/* all remaining fields are protected by the lock of the player */
struct vlc_player_listener_id *player_listener;