static void
playlist_delete_internal(struct playlist *playlist, unsigned song,
const struct song **queued_p)
{
unsigned songOrder;
assert(song < queue_length(&playlist->queue));
songOrder = queue_position_to_order(&playlist->queue, song);
if (playlist->playing && playlist->current == (int)songOrder) {
bool paused = pc_get_state() == PLAYER_STATE_PAUSE;
/* the current song is going to be deleted: stop the player */
pc_stop();
playlist->playing = false;
/* see which song is going to be played instead */
playlist->current = queue_next_order(&playlist->queue,
playlist->current);
if (playlist->current == (int)songOrder)
playlist->current = -1;
if (playlist->current >= 0 && !paused)
/* play the song after the deleted one */
playlist_play_order(playlist, playlist->current);
else
/* no songs left to play, stop playback
completely */
playlist_stop(playlist);
*queued_p = NULL;
} else if (playlist->current == (int)songOrder)
/* there's a "current song" but we're not playing
currently - clear "current" */
playlist->current = -1;
/* now do it: remove the song */
if (!song_in_database(queue_get(&playlist->queue, song)))
pc_song_deleted(queue_get(&playlist->queue, song));
queue_delete(&playlist->queue, song);
/* update the "current" and "queued" variables */
if (playlist->current > (int)songOrder) {
playlist->current--;
}
}
void
playlist_next(struct playlist *playlist, struct player_control *pc)
{
int next_order;
int current;
if (!playlist->playing)
return;
assert(!queue_is_empty(&playlist->queue));
assert(queue_valid_order(&playlist->queue, playlist->current));
current = playlist->current;
playlist->stop_on_error = false;
/* determine the next song from the queue's order list */
next_order = queue_next_order(&playlist->queue, playlist->current);
if (next_order < 0) {
/* no song after this one: stop playback */
playlist_stop(playlist, pc);
/* reset "current song" */
playlist->current = -1;
}
else
{
if (next_order == 0 && playlist->queue.random) {
/* The queue told us that the next song is the first
song. This means we are in repeat mode. Shuffle
the queue order, so this time, the user hears the
songs in a different than before */
assert(playlist->queue.repeat);
queue_shuffle_order(&playlist->queue);
/* note that playlist->current and playlist->queued are
now invalid, but playlist_play_order() will
discard them anyway */
}
playlist_play_order(playlist, pc, next_order);
}
/* Consume mode removes each played songs. */
if(playlist->queue.consume)
playlist_delete(playlist, pc,
queue_order_to_position(&playlist->queue,
current));
}
void playlist_clear(struct playlist *playlist)
{
playlist_stop(playlist);
/* make sure there are no references to allocated songs
anymore */
for (unsigned i = 0; i < queue_length(&playlist->queue); i++) {
const struct song *song = queue_get(&playlist->queue, i);
if (!song_in_database(song))
pc_song_deleted(song);
}
queue_clear(&playlist->queue);
playlist->current = -1;
playlist_increment_version(playlist);
}
VlcPluginBase::~VlcPluginBase()
{
free(psz_baseURL);
free(psz_target);
if( vlc_player::is_open() )
{
if( playlist_isplaying() )
playlist_stop();
events.unhook_manager( this );
vlc_player::close();
}
if( libvlc_instance )
libvlc_release( libvlc_instance );
_instances.erase(this);
}
/**
* The player has stopped for some reason. Check the error, and
* decide whether to re-start playback
*/
static void
playlist_resume_playback(struct playlist *playlist, struct player_control *pc)
{
enum player_error error;
assert(playlist->playing);
assert(pc_get_state(pc) == PLAYER_STATE_STOP);
error = pc_get_error_type(pc);
if (error == PLAYER_ERROR_NONE)
playlist->error_count = 0;
else
++playlist->error_count;
if ((playlist->stop_on_error && error != PLAYER_ERROR_NONE) ||
error == PLAYER_ERROR_OUTPUT ||
playlist->error_count >= queue_length(&playlist->queue))
/* too many errors, or critical error: stop
playback */
playlist_stop(playlist, pc);
else
/* continue playback at the next song */
playlist_next(playlist, pc);
}
void VlcPluginBase::control_handler(vlc_toolbar_clicked_t clicked)
{
switch( clicked )
{
case clicked_Play:
{
playlist_play();
}
break;
case clicked_Pause:
{
playlist_pause();
}
break;
case clicked_Stop:
{
playlist_stop();
}
break;
case clicked_Fullscreen:
{
toggle_fullscreen();
}
break;
case clicked_Mute:
case clicked_Unmute:
#if 0
{
if( p_md )
libvlc_audio_toggle_mute( p_md );
}
#endif
break;
case clicked_timeline:
#if 0
{
/* if a movie is loaded */
if( p_md )
{
int64_t f_length;
f_length = libvlc_media_player_get_length( p_md ) / 100;
f_length = (float)f_length *
( ((float)i_xPos-4.0 ) / ( ((float)i_width-8.0)/100) );
libvlc_media_player_set_time( p_md, f_length );
}
}
#endif
break;
case clicked_Time:
{
/* Not implemented yet*/
}
break;
default: /* button_Unknown */
fprintf(stderr, "button Unknown!\n");
break;
}
}
