// Initialization bool MediaPlayer::initialize( const std::string &url ) { LDEBUG( "vlc", "Initialize: url=%s", url.c_str() ); // Create media from url libvlc_media_t *m=libvlc_media_new_path( instance(), url.c_str() ); if (!m) { LERROR( "vlc", "Cannot initialize new media from url: url=%s", url.c_str() ); return false; } // Add common parameters libvlc_media_add_option( m, "verbose=1000" ); libvlc_media_add_option( m, "no-osd" ); libvlc_media_add_option( m, "ffmpeg-hw" ); // Create a media player playing environement _mp = libvlc_media_player_new_from_media(m); if (!_mp) { libvlc_media_release (m); LERROR( "vlc", "Cannot create media player from url: url=%s", url.c_str() ); return false; } // No need to keep the media now libvlc_media_release (m); { // Set WindowID VideoDescription desc; if (getVideoDescription( desc )) { #ifndef _WIN32 libvlc_media_player_set_xwindow( _mp, desc.winID ); #else libvlc_media_player_set_hwnd( _mp, desc ); #endif } } { // Attach to stop asyn events libvlc_event_manager_t *mgr=libvlc_media_player_event_manager( _mp ); libvlc_event_attach( mgr, libvlc_MediaPlayerEndReached, vlcCallback, this ); } return true; }
VLCWrapper::VLCWrapper (QObject *parent) : QObject (parent) , CurrentItem_ (-1) , IsPlayedFromQueue_ (false) { Instance_ = libvlc_instance_ptr (libvlc_new (sizeof (vlc_args) / sizeof (vlc_args[0]), vlc_args), libvlc_release); LPlayer_ = libvlc_media_list_player_ptr (libvlc_media_list_player_new (Instance_.get ()), libvlc_media_list_player_release); Player_ = libvlc_media_player_ptr (libvlc_media_player_new (Instance_.get ()), libvlc_media_player_release); List_ = libvlc_media_list_ptr (libvlc_media_list_new (Instance_.get ()), libvlc_media_list_release); libvlc_media_list_player_set_media_player (LPlayer_.get (), Player_.get ()); libvlc_media_list_player_set_media_list (LPlayer_.get (), List_.get ()); auto listEventManager = libvlc_media_list_player_event_manager (LPlayer_.get ()); libvlc_event_attach (listEventManager, libvlc_MediaListPlayerNextItemSet, ListEventCallback, this); auto playerEventManager = libvlc_media_player_event_manager (Player_.get ()); libvlc_event_attach (playerEventManager, libvlc_MediaPlayerPlaying, ListEventCallback, this); libvlc_event_attach (playerEventManager, libvlc_MediaPlayerStopped, ListEventCallback, this); libvlc_event_attach (playerEventManager, libvlc_MediaPlayerPaused, ListEventCallback, this); libvlc_event_attach (playerEventManager, libvlc_MediaPlayerEndReached, ListEventCallback, this); }
bool VlcMediaWidget::init() { const char *arguments[] = { "--no-video-title-show" }; vlcInstance = libvlc_new(sizeof(arguments) / sizeof(arguments[0]), arguments); if (vlcInstance == NULL) { Log("VlcMediaWidget::init: cannot create vlc instance") << QLatin1String(libvlc_errmsg()); return false; } vlcMediaPlayer = libvlc_media_player_new(vlcInstance); if (vlcMediaPlayer == NULL) { Log("VlcMediaWidget::init: cannot create vlc media player") << QLatin1String(libvlc_errmsg()); return false; } libvlc_event_manager_t *eventManager = libvlc_media_player_event_manager(vlcMediaPlayer); libvlc_event_e eventTypes[] = { libvlc_MediaPlayerEncounteredError, libvlc_MediaPlayerEndReached, libvlc_MediaPlayerLengthChanged, libvlc_MediaPlayerSeekableChanged, libvlc_MediaPlayerStopped, libvlc_MediaPlayerTimeChanged }; for (uint i = 0; i < (sizeof(eventTypes) / sizeof(eventTypes[0])); ++i) { if (libvlc_event_attach(eventManager, eventTypes[i], vlcEventHandler, this) != 0) { Log("VlcMediaWidget::init: cannot attach event handler") << eventTypes[i]; return false; } } libvlc_media_player_set_xwindow(vlcMediaPlayer, quint32(winId())); setAttribute(Qt::WA_NativeWindow); setAttribute(Qt::WA_PaintOnScreen); return true; }
static void xmr_player_dispose(GObject *object) { XmrPlayer *player = XMR_PLAYER(object); XmrPlayerPrivate *priv = player->priv; libvlc_event_manager_t *event_mgr; gint i; event_mgr = libvlc_media_player_event_manager(priv->player); for (i = 0; i < g_vlc_event_count; ++i) libvlc_event_detach(event_mgr, g_vlc_events[i], vlc_event_callback, player); if (priv->event_idle_id != 0) { g_source_remove (priv->event_idle_id); priv->event_idle_id = 0; } if (priv->event_queue) { g_async_queue_unref(priv->event_queue); priv->event_queue = NULL; } libvlc_media_player_release(priv->player); libvlc_release(priv->instance); G_OBJECT_CLASS(xmr_player_parent_class)->dispose(object); }
void Java_org_videolan_libvlc_MediaPlayer_nativeRelease(JNIEnv *env, jobject thiz) { vlcjni_object *p_obj = VLCJniObject_getInstance(env, thiz); if (!p_obj) return; /* TODO: REMOVE */ libvlc_event_manager_t *ev = libvlc_media_player_event_manager(p_obj->u.p_mp); static const libvlc_event_type_t mp_events[] = { libvlc_MediaPlayerPlaying, libvlc_MediaPlayerPaused, libvlc_MediaPlayerEndReached, libvlc_MediaPlayerStopped, libvlc_MediaPlayerVout, libvlc_MediaPlayerPositionChanged, libvlc_MediaPlayerTimeChanged, libvlc_MediaPlayerEncounteredError, libvlc_MediaPlayerESAdded, libvlc_MediaPlayerESDeleted, }; for(int i = 0; i < (sizeof(mp_events) / sizeof(*mp_events)); i++) libvlc_event_detach(ev, mp_events[i], vlc_event_callback, NULL); libvlc_media_player_release(p_obj->u.p_mp); VLCJniObject_release(env, thiz, p_obj); }
void NPlaybackEngineVlc::init() { int argc; const char **argv; NCore::cArgs(&argc, &argv); QVector<const char *> argVector; for (int i = 0; i < argc; ++i) argVector << argv[i]; argVector << "-I" << "dummy" << "--ignore-config" << "--no-xlib"; m_vlcInstance = libvlc_new(argVector.size(), &argVector[0]); m_mediaPlayer = libvlc_media_player_new(m_vlcInstance); m_eventManager = libvlc_media_player_event_manager(m_mediaPlayer); libvlc_event_attach(m_eventManager, libvlc_MediaPlayerEndReached, _eventHandler, this); m_oldVolume = -1; m_oldPosition = -1; m_oldState = N::PlaybackStopped; m_timer = new QTimer(this); connect(m_timer, SIGNAL(timeout()), this, SLOT(checkStatus())); m_timer->start(100); m_init = true; }
VlcMediaPlayer::VlcMediaPlayer(VlcInstance *instance) : QObject(instance) { _vlcMediaPlayer = libvlc_media_player_new(instance->core()); _vlcEvents = libvlc_media_player_event_manager(_vlcMediaPlayer); /* Disable mouse and keyboard events */ libvlc_video_set_key_input(_vlcMediaPlayer, false); libvlc_video_set_mouse_input(_vlcMediaPlayer, false); VlcError::showErrmsg(); _vlcAudio = new VlcAudio(this); _vlcVideo = new VlcVideo(this); #if LIBVLC_VERSION >= 0x020200 _vlcEqualizer = new VlcEqualizer(this); #endif _videoWidget = 0; _media = 0; createCoreConnections(); VlcError::showErrmsg(); }
static void MediaPlayer_newCommon(JNIEnv *env, jobject thiz, vlcjni_object *p_obj, jobject jwindow) { p_obj->p_sys = calloc(1, sizeof(vlcjni_object_sys)); if (!p_obj->u.p_mp || !p_obj->p_sys) { VLCJniObject_release(env, thiz, p_obj); throw_IllegalStateException(env, "can't create MediaPlayer instance"); return; } p_obj->p_sys->jwindow = (*env)->NewGlobalRef(env, jwindow); if (!p_obj->p_sys->jwindow) { VLCJniObject_release(env, thiz, p_obj); throw_IllegalStateException(env, "can't create MediaPlayer instance"); return; } libvlc_media_player_set_android_context(p_obj->u.p_mp, libvlc_get_jvm(), p_obj->p_sys->jwindow); VLCJniObject_attachEvents(p_obj, MediaPlayer_event_cb, libvlc_media_player_event_manager(p_obj->u.p_mp), mp_events); }
VlcVideoPlayer::VlcVideoPlayer(wxWindow* win, const VideoID& id, wxPoint pt, wxSize size) : wxPanel(win, wxID_ANY, pt, size), videoID_(id), firstPlay_(1) { SetBackgroundColour(axColor(0, 0, 0)); _DEBUG_ nb_time_callback = 0; // Create new VLC instance. char const* vlcOptions[] = {"--no-video-title-show"}; //Hide filename. vlcInstance = NULL; vlcPlayer = NULL; // Create VLC instance vlcInstance = libvlc_new(1, vlcOptions); if( vlcInstance ) { vlcPlayer = libvlc_media_player_new(vlcInstance); // Create VLC player if( vlcPlayer ) { // Create VLC EventManager vlcEventManager = libvlc_media_player_event_manager(vlcPlayer); if( !vlcEventManager ) { _DEBUG_ DSTREAM << "Can't create VLC Event Manager" << endl; wxMessageDialog (this, "Can't create VLC Event Manager"); } } else // vlcPlayer { _DEBUG_ DSTREAM << "Can't create player from vlcMedia" << endl; wxMessageDialog (this, "Can't create player from vlcMedia"); } } else // vlcInstance. { _DEBUG_ DSTREAM << "Can't Open VLC instance" << endl; wxMessageDialog (this, "Can't Open VLC instance"); } // libVLC events and callback if( vlcInstance && vlcPlayer && vlcEventManager ) { libvlc_event_attach(vlcEventManager, libvlc_MediaPlayerPositionChanged, VlcVideoPlayer::vlcPositionChanged, this); libvlc_event_attach(vlcEventManager, libvlc_MediaPlayerTimeChanged, VlcVideoPlayer::vlcTimeChanged, this); } }
VLCEventBridge::VLCEventBridge( VLCMediaPlayer* mediaplayer ) { Q_ASSERT( mediaplayer != 0 ); Q_ASSERT( mediaplayer->_mediaPlayer != 0 ); _mediaPlayer = mediaplayer; _eventManager = libvlc_media_player_event_manager( _mediaPlayer->_mediaPlayer ); if ( !_eventManager ) throw libvlc_errmsg(); }
void VLCHolderWnd::DetachFromLibVlcEventSystem() { libvlc_event_manager_t* em = libvlc_media_player_event_manager(_p_md); if(_LibVlcESAttached && em){ libvlc_event_detach(em, libvlc_MediaPlayerPositionChanged, OnLibVlcEvent, this); _LibVlcESAttached=false; } }
static void snapshot(libvlc_media_player_t *mp, int width, char *out_with_ext) { libvlc_event_manager_t *em = libvlc_media_player_event_manager(mp); assert(em); libvlc_event_attach(em, libvlc_MediaPlayerSnapshotTaken, callback, NULL); done = false; libvlc_video_take_snapshot(mp, 0, out_with_ext, width, 0); event_wait("Snapshot has not been written"); libvlc_event_detach(em, libvlc_MediaPlayerSnapshotTaken, callback, NULL); }
static void set_position(libvlc_media_player_t *mp) { libvlc_event_manager_t *em = libvlc_media_player_event_manager(mp); assert(em); libvlc_event_attach(em, libvlc_MediaPlayerPositionChanged, callback, NULL); done = false; libvlc_media_player_set_position(mp, VLC_THUMBNAIL_POSITION); event_wait("Couldn't set position"); libvlc_event_detach(em, libvlc_MediaPlayerPositionChanged, callback, NULL); }
bool CAVPlayer::Play(const std::string &strPath) { if (! m_pVLC_Inst) {// 如果播放引擎没有创建,则创建它 Init(); } if(strPath.empty() || ! m_pVLC_Inst) {// 如果链接地址为空,或播放引擎没创建,则直接返回 return false; } // 验证地址是网络地址,还是本地地址 bool bURL = false; bURL = IsURL(strPath); Stop(); bool bRet = false; libvlc_media_t *m = NULL; if (bURL) {// 网络路径 m = libvlc_media_new_location(m_pVLC_Inst, strPath.c_str()); } else {// 本地路径 m = libvlc_media_new_path(m_pVLC_Inst, strPath.c_str()); } if (m) { if (m_pVLC_Player = libvlc_media_player_new_from_media(m)) { libvlc_media_player_set_hwnd(m_pVLC_Player, m_hWnd); libvlc_media_player_play(m_pVLC_Player); m_bStatus = em_play;//播放状态 // 事件管理 libvlc_event_manager_t *vlc_evt_man = libvlc_media_player_event_manager(m_pVLC_Player); libvlc_event_attach(vlc_evt_man, libvlc_MediaPlayerPlaying,CAVPlayer::OnVLC_Event, this); libvlc_event_attach(vlc_evt_man, libvlc_MediaPlayerPositionChanged, CAVPlayer::OnVLC_Event, this); libvlc_event_attach(vlc_evt_man, libvlc_MediaPlayerEndReached, CAVPlayer::OnVLC_Event, this); bRet = true; } libvlc_media_release(m); } return bRet; }
bool Transcode::m_doTranscode( const QString &transStr ) { QString sout( ":sout=" ); sout += transStr; char const *vlc_argv[] = { "-I", "dummy", "--no-skip-frame", }; int vlc_argc = sizeof( vlc_argv ) / sizeof( *vlc_argv ); libvlc_exception_init( &m_vlcEx ); m_libvlc = libvlc_new( vlc_argc, vlc_argv, &m_vlcEx ); if ( catchVLCException( &m_vlcEx ) ) return false; m_vlcMedia = libvlc_media_new( m_libvlc, m_origVidPath.toLocal8Bit(), &m_vlcEx ); if ( catchVLCException( &m_vlcEx ) ) return false; libvlc_media_add_option(m_vlcMedia, sout.toStdString().c_str(), &m_vlcEx); if ( catchVLCException( &m_vlcEx ) ) return false; m_vlcMp = libvlc_media_player_new_from_media( m_vlcMedia, &m_vlcEx ); if ( catchVLCException( &m_vlcEx ) ) return false; m_vlcEM = libvlc_media_player_event_manager( m_vlcMp, &m_vlcEx ); if ( catchVLCException( &m_vlcEx ) ) return false; libvlc_event_attach( m_vlcEM, libvlc_MediaPlayerPlaying, m_callback, this, &m_vlcEx ); if ( catchVLCException( &m_vlcEx ) ) return false; libvlc_event_attach( m_vlcEM, libvlc_MediaPlayerEndReached, m_callback, this, &m_vlcEx ); if ( catchVLCException( &m_vlcEx ) ) return false; libvlc_media_player_play( m_vlcMp, &m_vlcEx ); if ( catchVLCException( &m_vlcEx ) ) return false; m_running = true; m_initProgressDialog(); return true; }
bool VLCAudioPlayer::init(QStringList opt) { handleOption(opt); const char * const vlc_args[] = { "-I", "dummy", "-A", optionValue["ao"].toString().toStdString().c_str(), /* Don't use any interface */ "--ignore-config", "--no-video"}; /* Don't use VLC's config */ libvlc_event_manager_t *em; libvlc_exception_init(&vlc_ex); inst = libvlc_new(sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args, &vlc_ex); mediaPlayer = libvlc_media_player_new(inst, &vlc_ex); em = libvlc_media_player_event_manager(mediaPlayer, &vlc_ex); return true; }
void MediaPlayer::finalize() { LDEBUG( "vlc", "Finalize" ); assert(_mp); { // Dettach to stop asyn events libvlc_event_manager_t *mgr=libvlc_media_player_event_manager( _mp ); libvlc_event_detach( mgr, libvlc_MediaPlayerEndReached, vlcCallback, this ); } // Release player libvlc_media_player_release( _mp ); _mp = NULL; MediaPlayerImpl::finalize(); }
VLCWrapperImpl::VLCWrapperImpl(void) : m_pVLCInstance(0), m_pMediaPlayer(0), m_pMedia(0), m_pEvtManager(0), m_EH(0), m_EvtH(0) { const char * const vlc_args[] = { "-I", "dummy", // No special interface "--ignore-config", // Don't use VLC's config "--plugins-cache", "--no-reset-plugins-cache", "--plugin-path=./plugins", #if defined(WIN32) "--one-instance", #endif "--ts-es-id-pid", "--video-on-top", "--vout-event=3", "--no-video-title-show", "--embedded-video", "--video-x=0", "--video-y=0", "--width=1", "--height=1", "--scale=1.0", "--no-video-deco", "--video-title=VLC/VIDEO", "--loop", }; // init the exception object. libvlc_exception_init (&m_VLCex); // init vlc modules, should be done only once m_pVLCInstance = libvlc_new (sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args, &m_VLCex); ProcessVLCException(&m_VLCex, m_EH); // Create a media player playing environement m_pMediaPlayer = libvlc_media_player_new(m_pVLCInstance, &m_VLCex); ProcessVLCException(&m_VLCex, m_EH); // Create an event manager for the player for handling e.g. time change events m_pEvtManager=libvlc_media_player_event_manager(m_pMediaPlayer, &m_VLCex); ProcessVLCException(&m_VLCex, m_EH); }
JNIEXPORT void JNICALL NAME(nativeRelease)(JNIEnv *env, jobject thiz) { vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, thiz, "mNativeMediaParseLock"); vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, thiz, "mNativeMediaParseCond"); /* wake up threads that waiting on prepare */ vlc_mutex_lock(parse_lock); setIntValue(env, thiz, "mNativeMediaParsed", 4); vlc_cond_broadcast(parse_cond); vlc_mutex_unlock(parse_lock); jint mLibVlcMediaPlayer = getIntValue(env, thiz, "mLibVlcMediaPlayer"); if (mLibVlcMediaPlayer != 0) { libvlc_event_manager_t *em; libvlc_media_player_t *mp = (libvlc_media_player_t*) mLibVlcMediaPlayer; libvlc_media_t *md = libvlc_media_player_get_media(mp); if (md) { em = libvlc_media_event_manager(md); for (int i = 0; i < sizeof(md_listening) / sizeof(*md_listening); i++) { libvlc_event_detach(em, md_listening[i], vlc_event_callback, thiz); } } em = libvlc_media_player_event_manager(mp); for (int i = 0; i < sizeof(mp_listening) / sizeof(*mp_listening); i++) { libvlc_event_detach(em, mp_listening[i], vlc_event_callback, thiz); } libvlc_media_player_stop(mp); libvlc_media_player_release(mp); setIntValue(env, thiz, "mLibVlcMediaPlayer", 0); } jint mLibVlcInstance = getIntValue(env, thiz, "mLibVlcInstance"); if (mLibVlcInstance != 0) { libvlc_instance_t *instance = (libvlc_instance_t*) mLibVlcInstance; libvlc_release(instance); setIntValue(env, thiz, "mLibVlcInstance", 0); } setIntValue(env, thiz, "mNativeMediaBufferingCount", 0); vlc_mutex_destroy(parse_lock); free(parse_lock); setIntValue(env, thiz, "mNativeMediaParseLock", 0); vlc_cond_destroy(parse_cond); free(parse_cond); setIntValue(env, thiz, "mNativeMediaParseCond", 0); freeClasses(env, thiz); }
VLCImageStream( const char* const* vlc_argv=0 ) : osg::ImageStream(), _vlcMedia(0) { if ( !vlc_argv ) { const char* vlc_args[] = { "--ignore-config", // don't use VLC's config "--data-path="VLC_PLUGIN_PATH }; _vlc = libvlc_new( sizeof(vlc_args)/sizeof(vlc_args[0]), vlc_args ); } else _vlc = libvlc_new( sizeof(vlc_argv)/sizeof(vlc_argv[0]), vlc_argv ); _vlcPlayer = libvlc_media_player_new( _vlc ); libvlc_event_attach( libvlc_media_player_event_manager(_vlcPlayer), libvlc_MediaPlayerStopped, &VLCImageStream::videoEndFunc, this ); _status = INVALID; }
VLC::~VLC() { if (_mediaPlayer) { libvlc_event_manager_t *eventManager = libvlc_media_player_event_manager(_mediaPlayer); libvlc_event_detach(eventManager, libvlc_MediaPlayerEndReached, VLC::handle_vlc_event, this); libvlc_media_player_stop(_mediaPlayer); libvlc_media_player_release(_mediaPlayer); _mediaPlayer = NULL; } if (_libvlc) { libvlc_release(_libvlc); _libvlc = NULL; } if (_curBuffer) { delete _curBuffer; } AC_DEBUG << "deleting VLC instance"; setTimeCode(as_string(0)); }
void VLCHolderWnd::LibVlcAttach(libvlc_media_player_t* p_md) { if(!_p_md){ _p_md = p_md; libvlc_media_player_set_hwnd(p_md, getHWND()); libvlc_event_manager_t* em = libvlc_media_player_event_manager(_p_md); if(em){ //We need set hook to catch doubleclicking (to switch to fullscreen and vice versa). //But libvlc media window not exist yet, //and we don't know when it will be created, nor ThreadId of it. //So we try catch first libvlc_MediaPlayerPositionChanged event, //(suppose wnd will be created to that moment)), //and then try set mouse hook. _LibVlcESAttached = 0==libvlc_event_attach(em, libvlc_MediaPlayerPositionChanged, OnLibVlcEvent, this); } } }
void VLCWindowsManager::VlcEvents( bool Attach ) { if( !VP() ) return; vlc_player& vp = *VP(); libvlc_event_manager_t* em = libvlc_media_player_event_manager( vp.get_mp() ); if( !em ) return; for( int e = libvlc_MediaPlayerMediaChanged; e <= libvlc_MediaPlayerVout; ++e ) { switch( e ) { //case libvlc_MediaPlayerMediaChanged: //case libvlc_MediaPlayerNothingSpecial: //case libvlc_MediaPlayerOpening: //case libvlc_MediaPlayerBuffering: case libvlc_MediaPlayerPlaying: //case libvlc_MediaPlayerPaused: //case libvlc_MediaPlayerStopped: //case libvlc_MediaPlayerForward: //case libvlc_MediaPlayerBackward: //case libvlc_MediaPlayerEndReached: //case libvlc_MediaPlayerEncounteredError: //case libvlc_MediaPlayerTimeChanged: case libvlc_MediaPlayerPositionChanged: //case libvlc_MediaPlayerSeekableChanged: //case libvlc_MediaPlayerPausableChanged: //case libvlc_MediaPlayerTitleChanged: //case libvlc_MediaPlayerSnapshotTaken: //case libvlc_MediaPlayerLengthChanged: //case libvlc_MediaPlayerVout: if( Attach ) libvlc_event_attach( em, e, OnLibVlcEvent_proxy, this ); else libvlc_event_detach( em, e, OnLibVlcEvent_proxy, this ); break; } } }
static void _file_set(struct _App *app) { if (app->opening) { libvlc_media_release(app->m); libvlc_media_player_release(app->mp); free(app->filename); } _em_str_read(app->em_read, &app->filename); app->m = libvlc_media_new_path(app->libvlc, app->filename); if (!app->m) { fprintf(stderr, "could not open path: \"%s\"\n", app->filename); return; } app->mp = libvlc_media_player_new_from_media(app->m); if (!app->mp) { fprintf(stderr, "could not create new player from media.\n"); return; } app->opening = 1; libvlc_video_set_format(app->mp, "RV32", DEFAULTWIDTH, DEFAULTHEIGHT, DEFAULTWIDTH * 4); libvlc_video_set_callbacks(app->mp, _tmp_lock, _tmp_unlock, _tmp_display, app); app->event_mgr = libvlc_media_player_event_manager(app->mp); libvlc_event_attach(app->event_mgr, libvlc_MediaPlayerPositionChanged, _event_cb, app); libvlc_event_attach(app->event_mgr, libvlc_MediaPlayerStopped, _event_cb, app); app->mevent_mgr = libvlc_media_event_manager(app->m); app->tmpbuffer = malloc(sizeof(char) * DEFAULTWIDTH * DEFAULTHEIGHT * 4); libvlc_audio_set_mute(app->mp, 1); libvlc_media_player_play(app->mp); }
VLCWrapperImpl::VLCWrapperImpl(void) : pVLCInstance_(0), pMediaPlayer_(0), pMedia_(0), pEventManager_(0), eventHandler(0) { const char * const vlc_args[] = { "-I", "dumy", // No special interface "--ignore-config", // Don't use VLC's config "--plugin-path=./plugins" }; // init vlc modules, should be done only once pVLCInstance_ = libvlc_new (sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args); // Create a media player playing environement pMediaPlayer_ = libvlc_media_player_new(pVLCInstance_); // Create an event manager for the player for handling e.g. time change events pEventManager_ = libvlc_media_player_event_manager(pMediaPlayer_); }
bool VLCPlayer::loadFile(const QString & filePath) { VLCPlayer::mutex.lock(); if (VLCPlayer::playbackInProgress == true) { qDebug() << "Playback already in progress !"; VLCPlayer::mutex.unlock(); return false; } void *pUserData = 0; libvlc_event_manager_t* eventManager = libvlc_media_player_event_manager(VLCPlayer::media_player); libvlc_event_attach(eventManager, libvlc_MediaPlayerTimeChanged, handleEvent, pUserData); libvlc_event_attach(eventManager, libvlc_MediaPlayerEndReached, handleEvent, pUserData); libvlc_event_attach(eventManager, libvlc_MediaPlayerPositionChanged, handleEvent, pUserData); QFile mediaFile(filePath); if (!mediaFile.open(QIODevice::ReadOnly)) { qDebug() << "Unable to open the file : " << filePath; VLCPlayer::mutex.unlock(); return false; } libvlc_media_t * media = libvlc_media_new_fd(VLCPlayer::inst, mediaFile.handle()); libvlc_media_player_set_media(VLCPlayer::media_player, media); libvlc_media_player_play(VLCPlayer::media_player); VLCPlayer::playbackInProgress = true; VLCPlayer::mutex.unlock(); while (VLCPlayer::playbackInProgress) { QTest::qSleep(1000); } mediaFile.close(); return true; }
void VlcVideoWidget::RestartPlayback() { if (!status.doRestart) return; status.doRestart = false; vlcPlayer_ = libvlc_media_player_new_from_media(vlcMedia_); libvlc_event_manager_t *em = libvlc_media_player_event_manager(vlcPlayer_); libvlc_event_attach(em, libvlc_MediaPlayerMediaChanged, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerOpening, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerBuffering, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerPlaying, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerPaused, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerStopped, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerEncounteredError, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerTimeChanged, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerPositionChanged, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerSeekableChanged, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerPausableChanged, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerTitleChanged, &VlcEventHandler, this); libvlc_event_attach(em, libvlc_MediaPlayerLengthChanged, &VlcEventHandler, this); libvlc_video_set_callbacks( vlcPlayer_, &CallBackLock, &CallBackUnlock, &CallBackDisplay, this); renderPixmap_ = QImage(status.sourceSize.width(), status.sourceSize.height(), QImage::Format_RGB32); libvlc_video_set_format(vlcPlayer_, "RV32", renderPixmap_.width(), renderPixmap_.height(), renderPixmap_.bytesPerLine()); if (!status.doNotPlayAfterRestart) { Play(); status.doNotPlayAfterRestart = false; } }
JNIEXPORT void JNICALL NAME(nativeCreate)(JNIEnv *env, jobject thiz) { initClasses(env, thiz); vlc_mutex_t *parse_lock = calloc(1, sizeof(vlc_mutex_t)); vlc_mutex_init(parse_lock); setIntValue(env, thiz, "mNativeMediaParseLock", (jint) parse_lock); vlc_cond_t *parse_cond = calloc(1, sizeof(vlc_cond_t)); vlc_cond_init(parse_cond); setIntValue(env, thiz, "mNativeMediaParseCond", (jint) parse_cond); setIntValue(env, thiz, "mNativeMediaBufferingCount", 0); const char *argv[] = {"-I", "dummy", "-vvv", "--no-plugins-cache", "--no-drop-late-frames", "--input-timeshift-path", "/data/local/tmp"}; libvlc_instance_t *instance = libvlc_new_with_builtins(sizeof(argv) / sizeof(*argv), argv, vlc_builtins_modules); setIntValue(env, thiz, "mLibVlcInstance", (jint) instance); libvlc_media_player_t *mp = libvlc_media_player_new(instance); setIntValue(env, thiz, "mLibVlcMediaPlayer", (jint) mp); /* throw? */ libvlc_event_manager_t *em = libvlc_media_player_event_manager(mp); for (int i = 0; i < sizeof(mp_listening) / sizeof(*mp_listening); i++) { libvlc_event_attach(em, mp_listening[i], vlc_event_callback, thiz); } }
VLC::VLC(asl::DLHandle theDLHandle) : CaptureDevice(), PlugInBase(theDLHandle), _EOF(false), _curBuffer(NULL), _libvlc(NULL), _mediaPlayer(NULL), _playTime(0) { char const *vlc_argv[] = { "--no-osd", //"-vvv", "--reset-plugins-cache", "--no-xlib" // tell VLC to not use Xlib }; int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv); _libvlc = libvlc_new(vlc_argc, vlc_argv); _mediaPlayer = libvlc_media_player_new(_libvlc); libvlc_event_manager_t *eventManager = libvlc_media_player_event_manager(_mediaPlayer); libvlc_event_attach(eventManager, libvlc_MediaPlayerEndReached, VLC::handle_vlc_event, this); }
void Java_org_videolan_libvlc_MediaList_loadPlaylist(JNIEnv *env, jobject thiz, jobject libvlcJava, jstring mrl, jobject items) { const char* p_mrl = (*env)->GetStringUTFChars(env, mrl, NULL); libvlc_media_t *p_md = libvlc_media_new_location((libvlc_instance_t*)(intptr_t)getLong(env, libvlcJava, "mLibVlcInstance"), p_mrl); libvlc_media_add_option(p_md, ":demux=playlist,none"); libvlc_media_add_option(p_md, ":run-time=1"); struct stopped_monitor* monitor = malloc(sizeof(struct stopped_monitor)); pthread_mutex_init(&monitor->doneMutex, NULL); pthread_cond_init(&monitor->doneCondVar, NULL); monitor->stopped = false; pthread_mutex_lock(&monitor->doneMutex); libvlc_media_player_t* p_mp = libvlc_media_player_new((libvlc_instance_t*)(intptr_t)getLong(env, libvlcJava, "mLibVlcInstance")); libvlc_media_player_set_video_title_display(p_mp, libvlc_position_disable, 0); libvlc_event_manager_t* ev = libvlc_media_player_event_manager(p_mp); libvlc_event_attach(ev, libvlc_MediaPlayerEndReached, stopped_callback, monitor); libvlc_media_player_set_media(p_mp, p_md); libvlc_media_player_play(p_mp); struct timespec deadline; clock_gettime(CLOCK_REALTIME, &deadline); deadline.tv_sec += 2; /* If "VLC can't open the file", return */ int mp_alive = 1; while(!(monitor->stopped) && mp_alive) { pthread_cond_timedwait(&monitor->doneCondVar, &monitor->doneMutex, &deadline); mp_alive = libvlc_media_player_will_play(p_mp); } pthread_mutex_unlock(&monitor->doneMutex); pthread_mutex_destroy(&monitor->doneMutex); pthread_cond_destroy(&monitor->doneCondVar); free(monitor); libvlc_media_player_release(p_mp); expand_media_internal(env, (libvlc_instance_t*)(intptr_t)getLong(env, libvlcJava, "mLibVlcInstance"), items, p_md); (*env)->ReleaseStringUTFChars(env, mrl, p_mrl); }