示例#1
0
void
xmr_player_resume(XmrPlayer *player)
{
	g_return_if_fail(player != NULL);

	libvlc_media_player_set_pause(player->priv->player, 0);
}
示例#2
0
文件: VLC.cpp 项目: artcom/y60vlc
 void
 VLC::pauseCapture() {
     AC_DEBUG << "pause capture";
     if (_mediaPlayer) {
         libvlc_media_player_set_pause(_mediaPlayer, 1);
     }
 };
示例#3
0
/**************************************************************************
 * 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 );
}
示例#4
0
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);
}
示例#5
0
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;
    }
}
示例#7
0
void
AudioOutput::pause()
{
    tDebug() << Q_FUNC_INFO;

    libvlc_media_player_set_pause( m_vlcPlayer, 1 );
//    setState( Paused );
}
示例#8
0
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;
}
示例#9
0
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;
}
示例#11
0
    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 );      
          }
        }

      }
    }
示例#12
0
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 );
    }
}
示例#13
0
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;
     }
}
示例#14
0
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);
}
示例#15
0
static void
_stop(struct _App *app)
{
   if (app->mp)
     libvlc_media_player_set_pause(app->mp, 1);
}
示例#16
0
void MediaPlayer::pause( bool pause ) {
	LDEBUG( "vlc", "Pause: param=%d", pause );
	assert(_mp);	
	//	Pause playing
	libvlc_media_player_set_pause(_mp, pause ? 1 : 0 );
}
示例#17
0
 virtual void pause()
 {
     libvlc_media_player_set_pause( _vlcPlayer, true );
     _status = PAUSED;
 }
示例#18
0
void VlcMediaWidget::setPaused(bool paused)
{
	libvlc_media_player_set_pause(vlcMediaPlayer, paused);
	// we don't monitor playing / buffering / paused state changes
	addPendingUpdates(PlaybackStatus);
}
示例#19
0
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);
}