void
xmr_player_resume(XmrPlayer *player)
{
g_return_if_fail(player != NULL);
libvlc_media_player_set_pause(player->priv->player, 0);
}
void
VLC::pauseCapture() {
AC_DEBUG << "pause capture";
if (_mediaPlayer) {
libvlc_media_player_set_pause(_mediaPlayer, 1);
}
};
/**************************************************************************
* Toggle pause.
**************************************************************************/
void libvlc_media_player_pause( libvlc_media_player_t *p_mi )
{
libvlc_state_t state = libvlc_media_player_get_state( p_mi );
bool playing = (state == libvlc_Playing || state == libvlc_Buffering);
libvlc_media_player_set_pause( p_mi, playing );
}
void libvlc_media_list_player_set_pause(libvlc_media_list_player_t * p_mlp,
int do_pause)
{
lock(p_mlp);
libvlc_media_player_set_pause(p_mlp->p_mi, do_pause);
unlock(p_mlp);
}
void NPlaybackEngineVlc::pause()
{
if (!hasMedia())
return;
libvlc_media_player_set_pause(m_mediaPlayer, true);
}
void VideoPlayer::pause()
{
if ( _status==PLAYING )
{
libvlc_media_player_set_pause( _vlcPlayer, true );
_status = PAUSED;
}
}
void
AudioOutput::pause()
{
tDebug() << Q_FUNC_INFO;
libvlc_media_player_set_pause( m_vlcPlayer, 1 );
// setState( Paused );
}
void Player::togglePause()
{
if(!isPlaying)
{
return;
}
/*Resume if 0, pause if other*/
if(inPause)
{
libvlc_media_player_set_pause(mediaPlayer, 0);
}
else
{
libvlc_media_player_set_pause(mediaPlayer, 1);
}
inPause = !inPause;
}
void VlcVideoPlayer::playPause()
{
if (firstPlay_)
{
libvlc_media_player_play(vlcPlayer);
firstPlay_ = !firstPlay_;
}
libvlc_media_player_set_pause(vlcPlayer, libvlc_media_player_is_playing(vlcPlayer));
}
void VideoPlayer::play()
{
if ( _status==PAUSED )
{
libvlc_media_player_set_pause( _vlcPlayer, false );
}
else if ( _status!=PLAYING )
{
libvlc_media_player_play( _vlcPlayer );
}
_status = PLAYING;
}
void VLCVideoWidgetDelegator::play(){
if( m_player != Nullptr ){
if( m_hasPaused ){
m_hasPaused = false;
libvlc_media_player_set_pause ( m_player, 0 );
}
else{
if( !m_isPlaying ){
m_isPlaying = !false;
libvlc_media_player_play ( m_player );
}
}
}
}
void
AudioOutput::play()
{
tDebug() << Q_FUNC_INFO << state();
if ( state() == Paused )
{
libvlc_media_player_set_pause( m_vlcPlayer, 0 );
}
else
{
setState( Loading );
libvlc_media_player_play( m_vlcPlayer );
}
}
static void
_play(struct _App *app)
{
float pos;
if (!app->mp)
return;
_em_read_safe(app->em_read, &pos, sizeof(pos));
if (app->playing)
{
libvlc_media_player_set_pause(app->mp, 0);
}
else
{
libvlc_time_t new_time = pos * 1000;
libvlc_media_player_play(app->mp);
libvlc_media_player_set_time(app->mp, new_time);
app->playing = 1;
}
}
JNIEXPORT void JNICALL NAME(nativePause)(JNIEnv *env, jobject thiz)
{
libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer");
libvlc_media_player_set_pause(mp, 1);
}
static void
_stop(struct _App *app)
{
if (app->mp)
libvlc_media_player_set_pause(app->mp, 1);
}
void MediaPlayer::pause( bool pause ) {
LDEBUG( "vlc", "Pause: param=%d", pause );
assert(_mp);
// Pause playing
libvlc_media_player_set_pause(_mp, pause ? 1 : 0 );
}
virtual void pause()
{
libvlc_media_player_set_pause( _vlcPlayer, true );
_status = PAUSED;
}
void VlcMediaWidget::setPaused(bool paused)
{
libvlc_media_player_set_pause(vlcMediaPlayer, paused);
// we don't monitor playing / buffering / paused state changes
addPendingUpdates(PlaybackStatus);
}
static void vlc_event_callback(const libvlc_event_t *ev, void *data)
{
JNIEnv *env;
jobject obj_VlcMediaPlayer = g_obj_VlcMediaPlayer;
jobject obj_VlcEvent;
int trigger = 1;
if ((*gJVM)->AttachCurrentThread(gJVM, &env, 0) < 0)
return;
obj_VlcEvent = (*env)->AllocObject(env, clz_VlcEvent);
if (!obj_VlcEvent)
return;
libvlc_media_t *media = (libvlc_media_t *) getIntValue(env, obj_VlcMediaPlayer, "mLibVlcMedia");
char *mrl = libvlc_media_get_mrl(media);
libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, obj_VlcMediaPlayer, "mLibVlcMediaPlayer");
vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParseLock");
vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParseCond");
(*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_eventType, ev->type);
switch (ev->type) {
case libvlc_MediaDurationChanged: {
int64_t duration = ev->u.media_duration_changed.new_duration;
(*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) duration);
break;
}
case libvlc_MediaStateChanged: {
int state = ev->u.media_state_changed.new_state;
(*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_intValue, state);
/* wake up if there is an error */
if (state == libvlc_MediaPlayerEncounteredError) {
vlc_mutex_lock(parse_lock);
setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParsed", 2);
vlc_cond_broadcast(parse_cond);
vlc_mutex_unlock(parse_lock);
}
break;
}
case libvlc_MediaParsedChanged: {
libvlc_media_player_play(mp);
trigger = 0;
break;
}
case libvlc_MediaPlayerBuffering: {
float cache = ev->u.media_player_buffering.new_cache;
(*env)->SetFloatField(env, obj_VlcEvent, f_VlcEvent_floatValue, cache);
int count = getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaBufferingCount");
if ((int) cache == 100) {
setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaBufferingCount", count + 1);
/* if it's the first time */
if (count == 0) {
/* send buffering update event now */
(*env)->CallVoidMethod(env, obj_VlcMediaPlayer, m_VlcMediaPlayer_onVlcEvent, obj_VlcEvent);
libvlc_media_player_set_pause(mp, 1);
/* asynchonous preparing is done */
vlc_mutex_lock(parse_lock);
setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParsed", 1);
vlc_cond_broadcast(parse_cond);
vlc_mutex_unlock(parse_lock);
/* simulate a media prepared event */
(*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_eventType, libvlc_MediaParsedChanged);
(*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, 1);
}
}
break;
}
case libvlc_MediaPlayerTimeChanged: {
int64_t time = ev->u.media_player_time_changed.new_time;
(*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) time);
break;
}
case libvlc_MediaPlayerPositionChanged: {
float position = ev->u.media_player_position_changed.new_position;
(*env)->SetFloatField(env, obj_VlcEvent, f_VlcEvent_floatValue, position);
break;
}
case libvlc_MediaPlayerSeekableChanged: {
int seekable = ev->u.media_player_seekable_changed.new_seekable;
(*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, seekable > 0);
break;
}
case libvlc_MediaPlayerPausableChanged: {
int pausable = ev->u.media_player_pausable_changed.new_pausable;
(*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, pausable > 0);
break;
}
case libvlc_MediaPlayerTitleChanged: {
int title = ev->u.media_player_title_changed.new_title;
(*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_intValue, title);
break;
}
case libvlc_MediaPlayerSnapshotTaken: {
char *p = ev->u.media_player_snapshot_taken.psz_filename;
jstring path = (*env)->NewStringUTF(env, p);
(*env)->SetObjectField(env, obj_VlcEvent, f_VlcEvent_stringValue, path);
break;
}
case libvlc_MediaPlayerLengthChanged: {
int64_t length = ev->u.media_player_length_changed.new_length;
(*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) length);
break;
}
default:
break;
}
if (trigger)
(*env)->CallVoidMethod(env, obj_VlcMediaPlayer, m_VlcMediaPlayer_onVlcEvent, obj_VlcEvent);
(*env)->DeleteLocalRef(env, obj_VlcEvent);
free(mrl);
/* EXPLAIN: this is called in pthread wrapper routines */
// (*gJVM)->DetachCurrentThread(gJVM);
}
