void VideoWidget::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) { if (newGeometry == oldGeometry) { QDeclarativeItem::geometryChanged(newGeometry,oldGeometry); return; } if (mediaLoaded) { //qDebug() << "Geometry Change:" << newGeometry; pixmapMutex.lock(); delete pix; pix = new QImage(newGeometry.width(),newGeometry.height(),QImage::Format_RGB32); //qDebug() << libvlc_media_get_state(pm); libvlc_video_set_format(mp, "RV32", newGeometry.width(), newGeometry.height(), newGeometry.width()*4); pixmapMutex.unlock(); } else { //qDebug() << "Geometry Change:" << newGeometry; pixmapMutex.lock(); delete pix; pix = new QImage(newGeometry.width(),newGeometry.height(),QImage::Format_RGB32); //qDebug() << libvlc_media_get_state(pm); pixmapMutex.unlock(); } QDeclarativeItem::geometryChanged(newGeometry,oldGeometry); }
void VPlayer::play() { if(mp){ if(state==Stop){ libvlc_media_track_info_t *info; libvlc_media_parse(m); int i=libvlc_media_get_tracks_info(m,&info); for(--i;i>=0;--i){ if(info[i].i_type==libvlc_track_video){ srcSize.setWidth (info[i].u.video.i_width); srcSize.setHeight(info[i].u.video.i_height); } } free(info); dstSize=srcSize; avpicture_alloc(&srcFrame,PIX_FMT_RGB32,srcSize.width(),srcSize.height()); avpicture_alloc(&dstFrame,PIX_FMT_RGB32,dstSize.width(),dstSize.height()); valid=true; libvlc_video_set_format(mp,"RV32",srcSize.width(),srcSize.height(),srcSize.width()*4); libvlc_video_set_callbacks(mp,lock,NULL,display,this); Utils::delayExec(50,[this](){libvlc_media_player_play(mp);}); } else{ libvlc_media_player_pause(mp); if(state==Play){ state=Pause; emit paused(); } else{ state=Play; } } } }
int LibvlcCamera::PrimeCapture() { Info("Priming capture from %s", mPath.c_str()); StringVector opVect = split(Options(), ","); // Set transport method as specified by method field, rtpUni is default if ( Method() == "rtpMulti" ) opVect.push_back("--rtsp-mcast"); else if ( Method() == "rtpRtsp" ) opVect.push_back("--rtsp-tcp"); else if ( Method() == "rtpRtspHttp" ) opVect.push_back("--rtsp-http"); opVect.push_back("--no-audio"); if ( opVect.size() > 0 ) { mOptArgV = new char*[opVect.size()]; Debug(2, "Number of Options: %d",opVect.size()); for (size_t i=0; i< opVect.size(); i++) { opVect[i] = trimSpaces(opVect[i]); mOptArgV[i] = (char *)opVect[i].c_str(); Debug(2, "set option %d to '%s'", i, opVect[i].c_str()); } } mLibvlcInstance = libvlc_new(opVect.size(), (const char* const*)mOptArgV); if ( mLibvlcInstance == NULL ) { Error("Unable to create libvlc instance due to: %s", libvlc_errmsg()); return -1; } mLibvlcMedia = libvlc_media_new_location(mLibvlcInstance, mPath.c_str()); if ( mLibvlcMedia == NULL ) { Error("Unable to open input %s due to: %s", mPath.c_str(), libvlc_errmsg()); return -1; } mLibvlcMediaPlayer = libvlc_media_player_new_from_media(mLibvlcMedia); if ( mLibvlcMediaPlayer == NULL ) { Error("Unable to create player for %s due to: %s", mPath.c_str(), libvlc_errmsg()); return -1; } libvlc_video_set_format(mLibvlcMediaPlayer, mTargetChroma.c_str(), width, height, width * mBpp); libvlc_video_set_callbacks(mLibvlcMediaPlayer, &LibvlcLockBuffer, &LibvlcUnlockBuffer, NULL, &mLibvlcData); mLibvlcData.bufferSize = width * height * mBpp; // Libvlc wants 32 byte alignment for images (should in theory do this for all image lines) mLibvlcData.buffer = (uint8_t*)zm_mallocaligned(64, mLibvlcData.bufferSize); mLibvlcData.prevBuffer = (uint8_t*)zm_mallocaligned(64, mLibvlcData.bufferSize); mLibvlcData.newImage.setValueImmediate(false); libvlc_media_player_play(mLibvlcMediaPlayer); return 0; }
/** File has to be in one of the following formats: [file://]filename Plain media file http://ip:port/file HTTP URL ftp://ip:port/file FTP URL mms://ip:port/file MMS URL screen:// Screen capture [dvd://][device][@raw_device] DVD device [vcd://][device] VCD device [cdda://][device] Audio CD device udp:[[<source address>]@[<bind address>][:<bind port>]] */ void open( const std::string& file, bool needPlay=true, unsigned int w=512, unsigned int h=512 ) { _vlcMedia = libvlc_media_new_path( _vlc, file.c_str() ); libvlc_media_player_set_media( _vlcPlayer, _vlcMedia ); libvlc_video_set_callbacks( _vlcPlayer, &VLCImageStream::lockFunc, &VLCImageStream::unlockFunc, &VLCImageStream::displayFunc, this ); libvlc_video_set_format( _vlcPlayer, "RGBA", w, h, w*4 ); allocateImage( w, h, 1, GL_RGBA, GL_UNSIGNED_BYTE ); if ( needPlay ) play(); }
void VideoPlayer::open( const std::string& file, unsigned int w, unsigned int h ) { if ( libvlc_media_player_is_playing(_vlcPlayer)==1 ) { libvlc_media_player_stop( _vlcPlayer ); libvlc_media_release( _vlcMedia ); } std::string protocol = osgDB::getServerProtocol( file ); if ( !protocol.empty() ) _vlcMedia = libvlc_media_new_location( _vlc, file.c_str() ); else _vlcMedia = libvlc_media_new_path( _vlc, file.c_str() ); libvlc_media_player_set_media( _vlcPlayer, _vlcMedia ); libvlc_video_set_callbacks( _vlcPlayer, &VideoPlayer::lockFunc, &VideoPlayer::unlockFunc, &VideoPlayer::displayFunc, this ); libvlc_video_set_format( _vlcPlayer, "RGBA", w, h, w*4 ); allocateImage( w, h, 1, GL_RGBA, GL_UNSIGNED_BYTE ); setInternalTextureFormat( GL_RGBA ); }
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); }
static void _file_set_done(struct _App *app) { int r; app->opening = 0; r = emotion_generic_shm_get(app->shmname, &app->vs, &app->vf); if (!r) { free(app->filename); libvlc_media_release(app->m); libvlc_media_player_release(app->mp); app->filename = NULL; app->m = NULL; app->mp = NULL; _send_cmd_start(app, EM_RESULT_FILE_SET_DONE); SEND_CMD_PARAM(app, r); _send_cmd_finish(app); } app->w = app->vs->width; app->h = app->vs->height; libvlc_video_set_format(app->mp, "RV32", app->w, app->h, app->w * 4); libvlc_video_set_callbacks(app->mp, _lock, _unlock, _display, app); libvlc_event_attach(app->event_mgr, libvlc_MediaPlayerPlaying, _event_cb, app); libvlc_event_attach(app->event_mgr, libvlc_MediaPlayerTimeChanged, _event_cb, app); libvlc_event_attach(app->event_mgr, libvlc_MediaPlayerLengthChanged, _event_cb, app); libvlc_event_attach(app->event_mgr, libvlc_MediaPlayerSeekableChanged, _event_cb, app); libvlc_audio_set_mute(app->mp, 0); _send_cmd_start(app, EM_RESULT_FILE_SET_DONE); SEND_CMD_PARAM(app, r); _send_cmd_finish(app); }
void VideoWidget::load(QString file) { qDebug() << "Loading media:" << file; m = libvlc_media_new_path(inst,file.toAscii());//libvlc_media_new_location (inst, file.toAscii()); if (!m) { qDebug() << "Error loading media location:" << libvlc_errmsg(); } mp = libvlc_media_player_new_from_media (m); if (!mp) { qDebug() << "Error loading media player" << libvlc_errmsg(); } libvlc_media_release (m); //libvlc_media_player_set_xwindow(mp, this->winId()); //Old code for loading to a winId libvlc_video_set_callbacks(mp, lock, unlock, display, this); libvlc_video_set_format(mp, "RV32", pix->width(), pix->height(), pix->width()*4); mediaLoaded = 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; } }
NetworkStream::NetworkStream(const char * networkStream, ImageProcessor * proc, int mediaWidth, int mediaHeight) { #if USE_VLC imageProcessor = proc; libVlcInstance = NULL; mediaPlayer = NULL; // Hack since callback functions require static instance. imProc = imageProcessor; const char * const vlc_args[] = { "--no-media-library", "--reset-plugins-cache", "--no-stats", "--no-osd", "--no-video-title-show", "--plugin-path=/usr/local/lib/"}; printf("Starting Network Stream: %dx%d\n", mediaWidth, mediaHeight); libVlcInstance = libvlc_new(6,vlc_args); libvlc_media_t * media = libvlc_media_new_path(libVlcInstance, networkStream); mediaPlayer = libvlc_media_player_new_from_media(media); libvlc_media_release(media); context = ( struct ctx* )malloc( sizeof( *context ) ); context->image = cvCreateImage(cvSize(mediaWidth, mediaHeight), IPL_DEPTH_8U, 4); context->pixels = (unsigned char *)context->image->imageData; //libvlc_media_player_set_media( mediaPlayer, media); libvlc_video_set_callbacks(mediaPlayer, lock, unlock, display, context); libvlc_video_set_format(mediaPlayer, "RV32", mediaWidth, mediaHeight, mediaWidth*4); #endif }
bool VideoPlayer::initPlayer(string mediaURL) { if(VideoPlayer::disabled == true) { return true; } #ifdef HAS_LIBVLC ctxPtr->libvlc = NULL; ctxPtr->m = NULL; ctxPtr->mp = NULL; ctxPtr->vlc_argv.clear(); ctxPtr->vlc_argv.push_back("--intf=dummy"); //ctxPtr->vlc_argv.push_back("--intf=http"); //ctxPtr->vlc_argv.push_back("--no-media-library"); ctxPtr->vlc_argv.push_back("--ignore-config"); /* Don't use VLC's config */ ctxPtr->vlc_argv.push_back("--no-xlib"); /* tell VLC to not use Xlib */ ctxPtr->vlc_argv.push_back("--no-video-title-show"); //ctxPtr->vlc_argv.push_back("--network-caching=10000"); if(loop == true) { ctxPtr->vlc_argv.push_back("--loop"); ctxPtr->vlc_argv.push_back("--repeat"); } #if defined(LIBVLC_VERSION_PRE_2) ctxPtr->vlc_argv_str.push_back("--plugin-path=" + pluginsPath); ctxPtr->vlc_argv.push_back(ctxPtr->vlc_argv_str[ctxPtr->vlc_argv_str.size()-1].c_str()); #endif #if defined(LIBVLC_VERSION_PRE_2) && defined(LIBVLC_VERSION_PRE_1_1_0) char clock[64], cunlock[64], cdata[64]; char cwidth[32], cheight[32], cpitch[32]; /* * Initialise libVLC */ sprintf(clock, "%lld", (long long int)(intptr_t)lock); sprintf(cunlock, "%lld", (long long int)(intptr_t)unlock); sprintf(cdata, "%lld", (long long int)(intptr_t)ctxPtr); sprintf(cwidth, "%i", width); sprintf(cheight, "%i", height); sprintf(cpitch, "%i", colorBits); vlc_argv.push_back("--vout"); vlc_argv.push_back("vmem"); vlc_argv.push_back("--vmem-width"); ctxPtr->vlc_argv_str.push_back(cwidth); ctxPtr->vlc_argv.push_back(ctxPtr->vlc_argv_str[ctxPtr->vlc_argv_str.size()-1].c_str()); vlc_argv.push_back("--vmem-height"); ctxPtr->vlc_argv_str.push_back(cheight); ctxPtr->vlc_argv.push_back(ctxPtr->vlc_argv_str[ctxPtr->vlc_argv_str.size()-1].c_str()); vlc_argv.push_back("--vmem-pitch"); ctxPtr->vlc_argv_str.push_back(cpitch); ctxPtr->vlc_argv.push_back(ctxPtr->vlc_argv_str[ctxPtr->vlc_argv_str.size()-1].c_str()); vlc_argv.push_back("--vmem-chroma"); vlc_argv.push_back("RV16"); vlc_argv.push_back("--vmem-lock"); ctxPtr->vlc_argv_str.push_back(clock); ctxPtr->vlc_argv.push_back(ctxPtr->vlc_argv_str[ctxPtr->vlc_argv_str.size()-1].c_str()); vlc_argv.push_back("--vmem-unlock"); ctxPtr->vlc_argv_str.push_back(cunlock); ctxPtr->vlc_argv.push_back(ctxPtr->vlc_argv_str[ctxPtr->vlc_argv_str.size()-1].c_str()); vlc_argv.push_back("--vmem-data"); ctxPtr->vlc_argv_str.push_back(cdata); ctxPtr->vlc_argv.push_back(ctxPtr->vlc_argv_str[ctxPtr->vlc_argv_str.size()-1].c_str()); #endif if(verboseEnabled) ctxPtr->vlc_argv.push_back("--verbose=2"); if(verboseEnabled) ctxPtr->vlc_argv.push_back("--extraintf=logger"); //log anything #if defined(WIN32) if(verboseEnabled) _putenv("VLC_VERBOSE=2"); #endif int vlc_argc = ctxPtr->vlc_argv.size(); // char const *vlc_argv[] = // { // //"--no-audio", /* skip any audio track */ // "--no-xlib", /* tell VLC to not use Xlib */ // "--no-video-title-show", // pluginParam.c_str(), // }; // int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv); #endif ctxPtr->empty = NULL; glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); // Init Texture glGenTextures(1, &ctxPtr->textureId); glBindTexture(GL_TEXTURE_2D, ctxPtr->textureId); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); ctxPtr->empty = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, colorBits, 0, 0, 0, 0); ctxPtr->surf = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, colorBits, 0x001f, 0x07e0, 0xf800, 0); ctxPtr->mutex = SDL_CreateMutex(); #ifdef HAS_LIBVLC /* * Initialize libVLC */ if(verboseEnabled) printf("Trying [%s]\n",getenv("VLC_PLUGIN_PATH")); #if defined(LIBVLC_VERSION_PRE_2) && defined(LIBVLC_VERSION_PRE_1_1_0) libvlc_exception_t ex; libvlc_exception_init(&ex); ctxPtr->libvlc = libvlc_new(ctxPtr->vlc_argc, &ctxPtr->vlc_argv[0],&ex); catchError(&ex); #else ctxPtr->libvlc = libvlc_new(vlc_argc, &ctxPtr->vlc_argv[0]); #endif if(verboseEnabled) printf("In [%s] Line: %d, libvlc [%p]\n",__FUNCTION__,__LINE__,ctxPtr->libvlc); /* It is meaningless to try all this because we have to restart mg to pickup new env vars #if defined(WIN32) if(libvlc == NULL) { // For windows check registry for install path std::string strValue = getRegKey("Software\\VideoLAN\\VLC", "InstallDir"); if(strValue != "") { if(strValue.length() >= 2) { if(strValue[0] == '"') { strValue = strValue.erase(0); } if(strValue[strValue.length()-1] == '"') { strValue = strValue.erase(strValue.length()-1); } } strValue = "VLC_PLUGIN_PATH=" + strValue; _putenv(strValue.c_str()); if(verboseEnabled) printf("Trying [%s]\n",getenv("VLC_PLUGIN_PATH")); libvlc = libvlc_new(vlc_argc, &vlc_argv[0]); } if(libvlc == NULL) { _putenv("VLC_PLUGIN_PATH=c:\\program files\\videolan\\vlc\\plugins"); if(verboseEnabled) printf("Trying [%s]\n",getenv("VLC_PLUGIN_PATH")); libvlc = libvlc_new(vlc_argc, &vlc_argv[0]); } if(libvlc == NULL) { _putenv("VLC_PLUGIN_PATH=\\program files\\videolan\\vlc\\plugins"); if(verboseEnabled) printf("Trying [%s]\n",getenv("VLC_PLUGIN_PATH")); libvlc = libvlc_new(vlc_argc, &vlc_argv[0]); } if(libvlc == NULL) { _putenv("VLC_PLUGIN_PATH=c:\\program files (x86)\\videolan\\vlc\\plugins"); if(verboseEnabled) printf("Trying [%s]\n",getenv("VLC_PLUGIN_PATH")); libvlc = libvlc_new(vlc_argc, &vlc_argv[0]); } if(libvlc == NULL) { _putenv("VLC_PLUGIN_PATH=\\program files (x86)\\videolan\\vlc\\plugins"); if(verboseEnabled) printf("Trying [%s]\n",getenv("VLC_PLUGIN_PATH")); libvlc = libvlc_new(vlc_argc, &vlc_argv[0]); } } #endif */ if(ctxPtr->libvlc != NULL) { #if defined(LIBVLC_VERSION_PRE_2) && defined(LIBVLC_VERSION_PRE_1_1_0) ctxPtr->m = libvlc_media_new(ctxPtr->libvlc, mediaURL.c_str(), &ex); if(verboseEnabled) printf("In [%s] Line: %d, m [%p]\n",__FUNCTION__,__LINE__,ctxPtr->m); catchError(&ex); ctxPtr->mp = libvlc_media_player_new_from_media(ctxPtr->m); if(verboseEnabled) printf("In [%s] Line: %d, mp [%p]\n",__FUNCTION__,__LINE__,ctxPtr->mp); libvlc_media_release(ctxPtr->m); #else if(mediaURL.find(HTTP_PREFIX) == 0) { ctxPtr->mlp = libvlc_media_list_player_new(ctxPtr->libvlc); ctxPtr->ml = libvlc_media_list_new(ctxPtr->libvlc); ctxPtr->m = libvlc_media_new_location(ctxPtr->libvlc, mediaURL.c_str()); libvlc_media_list_add_media(ctxPtr->ml, ctxPtr->m); } else { ctxPtr->m = libvlc_media_new_path(ctxPtr->libvlc, mediaURL.c_str()); } /* Create a new item */ if(verboseEnabled) printf("In [%s] Line: %d, m [%p]\n",__FUNCTION__,__LINE__,ctxPtr->m); if(loop == true) { libvlc_media_add_option(ctxPtr->m, "input-repeat=-1"); } if(mediaURL.find(HTTP_PREFIX) == 0) { ctxPtr->mp = libvlc_media_player_new(ctxPtr->libvlc); } else { ctxPtr->mp = libvlc_media_player_new_from_media(ctxPtr->m); } if(verboseEnabled) printf("In [%s] Line: %d, mp [%p]\n",__FUNCTION__,__LINE__,ctxPtr->mp); libvlc_media_player_set_media(ctxPtr->mp, ctxPtr->m); libvlc_media_release(ctxPtr->m); if(mediaURL.find(HTTP_PREFIX) == 0) { // Use our media list libvlc_media_list_player_set_media_list(ctxPtr->mlp, ctxPtr->ml); // Use a given media player libvlc_media_list_player_set_media_player(ctxPtr->mlp, ctxPtr->mp); } // Get an event manager for the media player. if(mediaURL.find(HTTP_PREFIX) == 0) { libvlc_event_manager_t *eventManager = libvlc_media_list_player_event_manager(ctxPtr->mlp); if(eventManager) { // libvlc_event_attach(eventManager, libvlc_MediaPlayerPlaying, (libvlc_callback_t)trapPlayingEvent, NULL, &ex); // libvlc_event_attach(eventManager, libvlc_MediaPlayerEndReached, (libvlc_callback_t)trapEndReachedEvent, NULL, &ex); // libvlc_event_attach(eventManager, libvlc_MediaPlayerBuffering, (libvlc_callback_t)trapBufferingEvent, NULL, &ex); // libvlc_event_attach(eventManager, libvlc_MediaPlayerEncounteredError, (libvlc_callback_t)trapErrorEvent, NULL, &ex); int event_added = libvlc_event_attach( eventManager, libvlc_MediaListPlayerNextItemSet, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaListPlayerNextItemSet]\n"); } } } //else { //libvlc_event_manager_t *eventManager = libvlc_media_player_event_manager(mp, &ex); libvlc_event_manager_t *eventManager = libvlc_media_player_event_manager(ctxPtr->mp); if(eventManager) { int event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerSnapshotTaken, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerSnapshotTaken]\n"); } // event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerTimeChanged, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerTimeChanged]\n"); // } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerPlaying, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerPlaying]\n"); } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerPaused, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerPaused]\n"); } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerStopped, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerStopped]\n"); } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerEndReached, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerEndReached]\n"); } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerPositionChanged, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerPositionChanged]\n"); } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerLengthChanged, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerLengthChanged]\n"); } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerEncounteredError,callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerEncounteredError]\n"); } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerPausableChanged, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerPausableChanged]\n"); } event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerSeekableChanged, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerSeekableChanged]\n"); } // event_added = libvlc_event_attach( eventManager, libvlc_MediaStateChanged, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaStateChanged]\n"); // } // event_added = libvlc_event_attach( eventManager, libvlc_MediaParsedChanged, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaParsedChanged]\n"); // } #if defined(LIBVLC_VERSION_PRE_2) && defined(LIBVLC_VERSION_PRE_1_1_0) event_added = libvlc_event_attach( eventManager, libvlc_MediaPlayerVout, callbacks, ctxPtr ); if(event_added != 0) { printf("ERROR CANNOT ADD EVENT [libvlc_MediaPlayerVout]\n"); } #endif // event_added = libvlc_event_attach( eventManager, libvlc_MediaListItemAdded, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListItemAdded]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListWillAddItem, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListWillAddItem]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListItemDeleted, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListItemDeleted]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListWillDeleteItem, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListWillDeleteItem]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListViewItemAdded, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListViewItemAdded]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListViewWillAddItem, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListViewWillAddItem]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListViewItemDeleted, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListViewItemDeleted]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListViewWillDeleteItem, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListViewWillDeleteItem]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListPlayerPlayed, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListPlayerPlayed]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListPlayerNextItemSet, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListPlayerNextItemSet]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaListPlayerStopped, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaListPlayerStopped]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaDiscovererStarted, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaDiscovererStarted]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_MediaDiscovererEnded, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_MediaDiscovererEnded]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaAdded, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaAdded]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaRemoved, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaRemoved]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaChanged, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaChanged]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaInstanceStarted, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaInstanceStarted]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaInstanceStopped, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaInstanceStopped]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaInstanceStatusInit, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaInstanceStatusInit]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaInstanceStatusOpening, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaInstanceStatusOpening]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaInstanceStatusPlaying, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaInstanceStatusPlaying]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaInstanceStatusPause, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaInstanceStatusPause]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaInstanceStatusEnd, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaInstanceStatusEnd]\n"); // } // // event_added = libvlc_event_attach( eventManager, libvlc_VlmMediaInstanceStatusError, callbacks, ctxPtr ); // if(event_added != 0) { // printf("ERROR CANNOT ADD EVENT [libvlc_VlmMediaInstanceStatusError]\n"); // } } //} //libvlc_media_release(ctxPtr->m); #endif #if !defined(LIBVLC_VERSION_PRE_2) && !defined(LIBVLC_VERSION_PRE_1_1_0) libvlc_video_set_callbacks(ctxPtr->mp, lock, unlock, display, ctxPtr); libvlc_video_set_format(ctxPtr->mp, "RV16", width, height, this->surface->pitch); #endif ctxPtr->isPlaying = true; #if defined(LIBVLC_VERSION_PRE_2) && defined(LIBVLC_VERSION_PRE_1_1_0) int play_result = libvlc_media_player_play(ctxPtr->mp,&ex); #else int play_result = 0; if(mediaURL.find(HTTP_PREFIX) == 0) { libvlc_media_list_player_play(ctxPtr->mlp); } else { play_result = libvlc_media_player_play(ctxPtr->mp); } // Play //int play_result = 0; //libvlc_media_list_player_play(ctxPtr->mlp); #endif //SDL_Delay(5); if(verboseEnabled) printf("In [%s] Line: %d, play_result [%d]\n",__FUNCTION__,__LINE__,play_result); successLoadingLib = (play_result == 0); } #endif return successLoadingLib; }
/** * Thumbnailer main function. * return null if the thumbail generation failed. **/ jbyteArray Java_org_videolan_vlc_LibVLC_getThumbnail(JNIEnv *env, jobject thiz, jint instance, jstring filePath, jint width, jint height) { libvlc_instance_t *libvlc = (libvlc_instance_t *)instance; jbyteArray byteArray = NULL; /* Create the thumbnailer data structure */ thumbnailer_sys_t *sys = calloc(1, sizeof(thumbnailer_sys_t)); if (sys == NULL) { LOGE("Couldn't create the thumbnailer data structure!"); return NULL; } /* Initialize the barrier. */ pthread_mutex_init(&sys->doneMutex, NULL); pthread_cond_init(&sys->doneCondVar, NULL); /* Create a media player playing environment */ sys->mp = libvlc_media_player_new(libvlc); libvlc_media_t *m = new_media(instance, env, thiz, filePath); if (m == NULL) { LOGE("Couldn't create the media to play!"); goto end; } libvlc_media_add_option( m, ":no-audio" ); libvlc_media_player_set_media(sys->mp, m); libvlc_media_release(m); /* Get the size of the video with the tracks information of the media. */ libvlc_media_track_info_t *tracks; libvlc_media_parse(m); int nbTracks = libvlc_media_get_tracks_info(m, &tracks); unsigned i, videoWidth, videoHeight; bool hasVideoTrack = false; for (i = 0; i < nbTracks; ++i) if (tracks[i].i_type == libvlc_track_video) { videoWidth = tracks[i].u.video.i_width; videoHeight = tracks[i].u.video.i_height; hasVideoTrack = true; break; } free(tracks); /* Abord if we have not found a video track. */ if (!hasVideoTrack) { LOGE("Could not find a video track in this file.\n"); goto end; } /* Compute the size parameters of the frame to generate. */ unsigned picWidth = width; unsigned picHeight = height; float videoAR = (float)videoWidth / videoHeight; float screenAR = (float)width / height; if (screenAR < videoAR) { picHeight = (float)width / videoAR; sys->thumbnailOffset = (height - picHeight) / 2 * width * PIXEL_SIZE; } else { picWidth = (float)height * videoAR; sys->thumbnailOffset = (width - picWidth) / 2 * PIXEL_SIZE; } sys->picPitch = picWidth * PIXEL_SIZE; sys->lineSize = width * PIXEL_SIZE; sys->nbLines = picHeight; /* Allocate the memory to store the frames. */ unsigned picSize = sys->picPitch * picHeight; sys->frameData = malloc(picSize); if (sys->frameData == NULL) { LOGE("Couldn't allocate the memory to store the frame!"); goto end; } /* Allocate the memory to store the thumbnail. */ unsigned thumbnailSize = width * height * PIXEL_SIZE; sys->thumbnail = calloc(thumbnailSize, 1); if (sys->thumbnail == NULL) { LOGE("Couldn't allocate the memory to store the thumbnail!"); goto end; } /* Set the video format and the callbacks. */ libvlc_video_set_format(sys->mp, "RGBA", picWidth, picHeight, sys->picPitch); libvlc_video_set_callbacks(sys->mp, thumbnailer_lock, thumbnailer_unlock, NULL, (void*)sys); /* Play the media. */ libvlc_media_player_play(sys->mp); libvlc_media_player_set_position(sys->mp, THUMBNAIL_POSITION); /* Wait for the thumbnail to be generated. */ pthread_mutex_lock(&sys->doneMutex); while (!sys->hasThumb) pthread_cond_wait(&sys->doneCondVar, &sys->doneMutex); pthread_mutex_unlock(&sys->doneMutex); /* Stop and realease the media player. */ libvlc_media_player_stop(sys->mp); libvlc_media_player_release(sys->mp); /* Create the Java byte array to return the create thumbnail. */ byteArray = (*env)->NewByteArray(env, thumbnailSize); if (byteArray == NULL) { LOGE("Couldn't allocate the Java byte array to store the frame!"); goto end; } (*env)->SetByteArrayRegion(env, byteArray, 0, thumbnailSize, (jbyte *)sys->thumbnail); (*env)->DeleteLocalRef(env, byteArray); end: pthread_mutex_destroy(&sys->doneMutex); pthread_cond_destroy(&sys->doneCondVar); free(sys->thumbnail); free(sys->frameData); free(sys); return byteArray; }
bool VLCVideoWrapper::open(const std::string& ThePath, Window* const TheWindow) { bool errorOpening(false); //BoostPath PluginsDirPath("/Applications/VLC.app/Contents/MacOS/modules"); BoostPath PluginsDirPath("/Applications/VLC-1.1.7.app/Contents/MacOS/modules"); std::vector<std::string> VLCArguments; VLCArguments.push_back("-I"); VLCArguments.push_back("dummy"); /* no interface */ VLCArguments.push_back(std::string("--plugin-path=") + PluginsDirPath.string()); //VLCArguments.push_back("--no-audio"); [> we don't want audio <] VLCArguments.push_back("--verbose=0"); /* show only errors */ VLCArguments.push_back("--no-media-library");/* don't want that */ VLCArguments.push_back("--services-discovery=");/* don't want that */ VLCArguments.push_back("--no-video-title-show");/* don't want that */ VLCArguments.push_back("--no-stats");/* don't want that */ VLCArguments.push_back("--ignore-config"); /* don't use/overwrite the config */ VLCArguments.push_back("--no-sub-autodetect");/* don't want subtitles */ VLCArguments.push_back("--control=");/* don't want interface (again) */ VLCArguments.push_back("--no-disable-screensaver");/* don't want that */ // libvlc settings const char** args = new const char*[VLCArguments.size()]; for(UInt32 i(0) ; i<VLCArguments.size() ; ++i) { args[i] = VLCArguments[i].c_str(); } /* * Initialise libVLC */ UInt32 nargs = VLCArguments.size(); _VLCInstance = libvlc_new( nargs, args ); if(_VLCInstance == NULL) { checkVLCError("creating new vlc instance"); return false; } delete [] args; // creates vlc struct holding data to the video file libvlc_media_t *TheMedia = libvlc_media_new_path( _VLCInstance, ThePath.c_str() ); checkVLCError("initializing media file"); // initialize a temporary media player so we can get height and width before // adding the vmem options to TheMedia libvlc_media_player_t * tempMediaPlayer = libvlc_media_player_new_from_media( TheMedia ); unsigned Width(200), Height(200); libvlc_video_set_callbacks(tempMediaPlayer, lock, unlock, display, &_VideoMemContext); _VideoMemContext._pixels = ( UInt8* )malloc( ( sizeof( *( _VideoMemContext._pixels ) ) * Width * Height ) * 4 ); libvlc_video_set_format(tempMediaPlayer, "RV24", Width, Height, Width * 3); //Release the media file libvlc_media_release( TheMedia ); libvlc_media_player_play( tempMediaPlayer ); checkVLCError("playing the media"); libvlc_state_t currentState; do { currentState = libvlc_media_player_get_state(tempMediaPlayer); checkVLCError("getting state"); } while(currentState != libvlc_Playing); int VLCResult; do { VLCResult = libvlc_video_get_size(tempMediaPlayer, 0, &Width, &Height); } while(VLCResult != 0); checkVLCError("getting size"); libvlc_media_player_stop( tempMediaPlayer ); libvlc_media_player_release(tempMediaPlayer);// releases media currently in use //Now that we have the size initialize the media again TheMedia = libvlc_media_new_path( _VLCInstance, ThePath.c_str() ); checkVLCError("initializing media file"); // initialize the media player _MediaPlayer = libvlc_media_player_new_from_media( TheMedia ); checkVLCError("initializing media player"); //Release the media file libvlc_media_release( TheMedia ); #ifdef __APPLE__ //set agl handle (if TheWindow is pointing to a carbon window) if (TheWindow->getType().isDerivedFrom(CarbonWindow::getClassType())) { HIWindowRef windowRef = aglGetWindowRef(dynamic_cast<CarbonWindow* const>(TheWindow)->getContext()); HIViewRef contentView = 0; GetRootControl(windowRef, &contentView); //uint32_t aglHandler = CarbonWindowPtr::dcast(TheWindow)->winId(); libvlc_media_player_set_agl (_MediaPlayer, reinterpret_cast<uint32_t>(contentView) ); checkVLCError("attaching media player to carbon window"); } #endif #ifdef WIN32 if (TheWindow->getType().isDerivedFrom(WIN32Window::getClassType())) { libvlc_media_player_set_hwnd (_MediaPlayer, dynamic_cast<WIN32Window* const>(TheWindow)->getHwnd() ); checkVLCError("attaching media player to WIN32 window"); } #endif #ifdef __linux if (TheWindow->getType().isDerivedFrom(XWindow::getClassType())) { libvlc_media_player_set_xwindow (_MediaPlayer, dynamic_cast<XWindow* const>(TheWindow)->getDisplay() ); checkVLCError("attaching media player to Xwindow"); } #endif libvlc_video_set_callbacks(_MediaPlayer, lock, unlock, display, &_VideoMemContext); _VideoMemContext._pixels = ( UInt8* )malloc( ( sizeof( *( _VideoMemContext._pixels ) ) * Width * Height ) * 4 ); libvlc_video_set_format(_MediaPlayer, "RV24", Width, Height, Width * 3); //Start playing the video libvlc_media_player_play( _MediaPlayer ); checkVLCError("playing the media"); do { currentState = libvlc_media_player_get_state(_MediaPlayer); checkVLCError("getting state"); } while(currentState != libvlc_Playing); clock_t endwait; endwait = clock () + 2 * CLOCKS_PER_SEC ; while (clock() < endwait) {} _Initialized = true; // check if the player can be paused if(libvlc_media_player_can_pause(_MediaPlayer)) { // can pause it? do it libvlc_media_player_pause(_MediaPlayer); // error checking of course checkVLCError("pausing media player"); libvlc_media_player_set_position( _MediaPlayer, 0.0f ); checkVLCError("setting position during player initialization"); } return errorOpening; }
int Ibex::VLCVideoPlayer::playVLCVideo(const char *fileName, Display *dpy, GLXDrawable root) { libvlc_instance_t *libvlc; libvlc_media_t *m; libvlc_media_player_t *mp; char const *vlc_argv[] = { //"-H" "--text-renderer","none" //"--reset-plugins-cache", //"--reset-config" //"--no-audio", // Don't play audio. //"--no-xlib" // Don't use Xlib. // Apply a video filter. //"--video-filter", "sepia", //"--sepia-intensity=200" }; int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv); int done = 0, action = 0, pause = 0; struct context context; context.isStereo = 0; context.videoTexture = videoTexture; context.player = this; context.dpy = dpy; context.root = root; context.data = data; // create texture/mutex // If you don't have this variable set you must have plugins directory // with the executable or libvlc_new() will not work! printf("VLC_PLUGIN_PATH=%s\n", getenv("VLC_PLUGIN_PATH")); // Initialise libVLC. libvlc = libvlc_new(vlc_argc, vlc_argv); if(NULL == libvlc) { printf("LibVLC initialization failure.\n"); return EXIT_FAILURE; } m = libvlc_media_new_path(libvlc, fileName); mp = libvlc_media_player_new_from_media(m); libvlc_media_release(m); pixels = new uint32_t[VIDEOWIDTH*VIDEOHEIGHT*4]; memset(pixels, 0, sizeof(uint32_t)*VIDEOWIDTH*VIDEOHEIGHT*4); libvlc_video_set_callbacks(mp, vlclock, vlcunlock, vlcdisplay, &context); libvlc_video_set_format(mp, "RV32", VIDEOWIDTH, VIDEOHEIGHT, VIDEOWIDTH*sizeof(uint32_t)); //libvlc_video_set_format(mp, "YUYV", VIDEOWIDTH, VIDEOHEIGHT, VIDEOWIDTH*2); if(libvlc_video_get_size(mp, 0, &width, & height) == 0) { VIDEOWIDTH = width; VIDEOHEIGHT = height; } context.mp = mp; libvlc_media_player_play(mp); // Main loop. while(!done) { action = 0; switch(action) { case 'q': done = 1; break; case ' ': printf("Pause toggle.\n"); pause = !pause; break; } if(!pause) { context.n++; } std::this_thread::sleep_for(std::chrono::milliseconds(100)); } // Stop stream and clean up libVLC. libvlc_media_player_stop(mp); libvlc_media_player_release(mp); libvlc_release(libvlc); // delete mutex/texture info quit(0); return 0; }
/** * Entry point (main func) */ int main(int argc, char **argv) { // Init SDL + OpenGL if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) == -1) { return -1; } SDL_SetVideoMode(W, H, 16, SDL_OPENGL); glewInit(); glEnable(GL_TEXTURE_2D); glEnable(GL_DEPTH_TEST); // Init Textures glGenTextures(1, &textureId); glBindTexture(GL_TEXTURE_2D, textureId); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenTextures(1, &textureId2); glBindTexture(GL_TEXTURE_2D, textureId2); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenTextures(1, &textureId3); glBindTexture(GL_TEXTURE_2D, textureId3); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Init SDL_surfaces sdlStruct.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0); sdlStruct.sdlMutex = SDL_CreateMutex(); sdlStruct2.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0); sdlStruct2.sdlMutex = SDL_CreateMutex(); sdlStruct3.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0); sdlStruct3.sdlMutex = SDL_CreateMutex(); // Init LibVLC + media player const char *vlc_argv[] = {}; int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv); libvlc_instance_t * libVlcInstance = libvlc_new(vlc_argc, vlc_argv); libvlc_media_t * media = libvlc_media_new_path(libVlcInstance, VIDEOFILE); libvlc_media_player_t * mediaPlayer = libvlc_media_player_new_from_media(media); libvlc_media_release(media); libvlc_release(libVlcInstance); libvlc_video_set_callbacks(mediaPlayer, lockfct, unlockfct, NULL, &sdlStruct); libvlc_video_set_format(mediaPlayer, "RV16", W, H, W*2); // Init LibVLC Round2 libvlc_instance_t * libVlcInstance2 = libvlc_new(vlc_argc, vlc_argv); libvlc_media_t * media2 = libvlc_media_new_path(libVlcInstance2, VIDEOFILE2); libvlc_media_player_t * mediaPlayer2 = libvlc_media_player_new_from_media(media2); libvlc_media_release(media2); libvlc_release(libVlcInstance2); libvlc_video_set_callbacks(mediaPlayer2, lockfct2, unlockfct2, NULL, &sdlStruct2); libvlc_video_set_format(mediaPlayer2, "RV16", W, H, W*2); //Round 3 libvlc_instance_t * libVlcInstance3 = libvlc_new(vlc_argc, vlc_argv); libvlc_media_t * media3 = libvlc_media_new_path(libVlcInstance3, VIDEOFILE3); libvlc_media_player_t * mediaPlayer3 = libvlc_media_player_new_from_media(media3); libvlc_media_release(media3); libvlc_release(libVlcInstance3); libvlc_video_set_callbacks(mediaPlayer3, lockfct3, unlockfct3, NULL, &sdlStruct3); libvlc_video_set_format(mediaPlayer3, "RV16", W, H, W*2); // Start reading the video libvlc_media_player_play(mediaPlayer); libvlc_media_player_play(mediaPlayer2); libvlc_media_player_play(mediaPlayer3); libvlc_state_t state = libvlc_media_player_get_state(mediaPlayer); while ((state != libvlc_Ended) && (state != libvlc_Error)) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); loadTexture(); // Loading the texture // Square glBegin(GL_QUADS); glTexCoord2d(0, 0); glVertex2f(-0.95, 0.00); glTexCoord2d(0, 1); glVertex2f(-0.95, 0.95); glTexCoord2d(1, 1); glVertex2f(0.00, 0.95); glTexCoord2d(1, 0); glVertex2f(0.00, 0.00); glEnd(); loadTexture2(); glBegin(GL_QUADS); glTexCoord2d(0, 0); glVertex2f(0.05, 0.00); glTexCoord2d(0, 1); glVertex2f(0.05, 0.95); glTexCoord2d(1, 1); glVertex2f(0.95, 0.95); glTexCoord2d(1, 0); glVertex2f(0.95, 0.00); glEnd(); loadTexture3(); glBegin(GL_QUADS); glTexCoord2d(0, 0); glVertex2f(-0.95, -0.95); glTexCoord2d(0, 1); glVertex2f(-0.95, -0.05); glTexCoord2d(1, 1); glVertex2f(0.00, -0.05); glTexCoord2d(1, 0); glVertex2f(0.0, -0.95); glEnd(); glFlush(); SDL_GL_SwapBuffers(); SDL_Delay(10); state = libvlc_media_player_get_state(mediaPlayer); } // Frees libvlc_media_player_stop(mediaPlayer); libvlc_media_player_stop(mediaPlayer2); libvlc_media_player_stop(mediaPlayer3); libvlc_media_player_release(mediaPlayer); libvlc_media_player_release(mediaPlayer2); libvlc_media_player_release(mediaPlayer3); SDL_DestroyMutex(sdlStruct.sdlMutex); SDL_FreeSurface(sdlStruct.sdlSurface); SDL_DestroyMutex(sdlStruct2.sdlMutex); SDL_FreeSurface(sdlStruct2.sdlSurface); SDL_DestroyMutex(sdlStruct3.sdlMutex); SDL_FreeSurface(sdlStruct3.sdlSurface); SDL_Quit(); return 0; }
bool VLCVideoTextureObjChunk::createVLCInstance(libvlc_time_t start_time, bool play ) { libvlc_media_t *m; char const *vlc_argv[] = { "-I", "dumy", // No special interface "--ignore-config", // Don't use VLC's config "--quiet", // deactivates VLCs console outputs "--no-xlib", // tell VLC to not use Xlib "--no-video-title-show", // no titles }; int vlc_argc = sizeof(vlc_argv ) / sizeof(*vlc_argv ); // Initialize libVLC if (libvlc==NULL) { libvlc = libvlc_new(vlc_argc, vlc_argv); } else { if (vlcmediaplayer!=NULL) { ctx.idstr = NULL; libvlc_media_player_stop(vlcmediaplayer); libvlc_media_player_release(vlcmediaplayer); vlcmediaplayer = NULL; if (ctx.videothread!=NULL) { ctx.videothread->runFunction(NULL,NULL); // reset thread structure: isInititialized=false } ctx.videothread = NULL; } } m = libvlc_media_new_path(libvlc, getUrl().c_str()); vlcmediaplayer = libvlc_media_player_new_from_media(m); libvlc_media_release(m); ctx.idstr = strdup((std::string("video")+getVideoID()).c_str()); ctx.videothread = NULL; ctx.img = Image::create(); ctx.img->set(OSG::Image::OSG_BGR_PF,getWidth(), getHeight()); ctx.lock = Lock::create(); this->setImage(ctx.img); this->setTarget(GL_TEXTURE_2D); ctx.self = this; vlceventmgr = libvlc_media_player_event_manager( vlcmediaplayer ); // attach event to defined event handler callback libvlc_event_attach( vlceventmgr, libvlc_MediaPlayerEndReached, vlc_event, &ctx); libvlc_video_set_callbacks(vlcmediaplayer, vlc_lock, vlc_unlock, vlc_display, &ctx); libvlc_video_set_format(vlcmediaplayer, "RV24", getWidth(), getHeight(), getWidth()*3); if (getIsMaster()==false) libvlc_audio_set_mute(vlcmediaplayer, 1); #if 0 { SLOG << "available filters:" << std::endl; libvlc_module_description_t *list = libvlc_video_filter_list_get(libvlc); libvlc_module_description_t *iter = list; while(iter!=NULL) { SLOG << iter->psz_name << std::endl; iter = iter->p_next; } libvlc_module_description_list_release(list); } #endif libvlc_media_player_play(vlcmediaplayer); libvlc_media_player_set_time(vlcmediaplayer, start_time); if (!play) libvlc_media_player_pause(vlcmediaplayer); //not working? // add to static list //allVideoTextures.push_back(&ctx); lastSync=OSG::getTimeStamp(); return true; }
int main(int argc, char *argv[]) { libvlc_instance_t *libvlc; libvlc_media_t *m; libvlc_media_player_t *mp; char const *vlc_argv[] = { "--no-audio", // Don't play audio. "--no-xlib", // Don't use Xlib. // Apply a video filter. //"--video-filter", "sepia", //"--sepia-intensity=200" }; int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv); SDL_Event event; int done = 0, action = 0, pause = 0, n = 0; struct context context; if (argc < 2) { printf("Usage: %s <filename>\n", argv[0]); return EXIT_FAILURE; } // Initialise libSDL. if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("Could not initialize SDL: %s.\n", SDL_GetError()); return EXIT_FAILURE; } // Create SDL graphics objects. SDL_Window * window = SDL_CreateWindow( "Simple VLC player", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WIDTH, HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE); if (!window) { fprintf(stderr, "Couldn't create window: %s\n", SDL_GetError()); quit(3); } context.renderer = SDL_CreateRenderer(window, -1, 0); if (!context.renderer) { fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError()); quit(4); } context.texture = SDL_CreateTexture( context.renderer, SDL_PIXELFORMAT_BGR565, SDL_TEXTUREACCESS_STREAMING, VIDEOWIDTH, VIDEOHEIGHT); if (!context.texture) { fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError()); quit(5); } context.mutex = SDL_CreateMutex(); // If you don't have this variable set you must have plugins directory // with the executable or libvlc_new() will not work! printf("VLC_PLUGIN_PATH=%s\n", getenv("VLC_PLUGIN_PATH")); // Initialise libVLC. libvlc = libvlc_new(vlc_argc, vlc_argv); if (NULL == libvlc) { printf("LibVLC initialization failure.\n"); return EXIT_FAILURE; } m = libvlc_media_new_path(libvlc, argv[1]); mp = libvlc_media_player_new_from_media(m); libvlc_media_release(m); libvlc_video_set_callbacks(mp, lock, unlock, display, &context); libvlc_video_set_format(mp, "RV16", VIDEOWIDTH, VIDEOHEIGHT, VIDEOWIDTH * 2); int result = libvlc_media_player_play(mp); // Main loop. while (!done) { action = 0; // Keys: enter (fullscreen), space (pause), escape (quit). while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_QUIT: done = 1; break; case SDL_KEYDOWN: action = event.key.keysym.sym; break; } } switch (action) { case SDLK_ESCAPE: case SDLK_q: done = 1; break; case ' ': printf("Pause toggle.\n"); pause = !pause; break; } if (!pause) { context.n++; } SDL_Delay(1000 / 10); } // Stop stream and clean up libVLC. libvlc_media_player_stop(mp); libvlc_media_player_release(mp); libvlc_release(libvlc); // Close window and clean up libSDL. SDL_DestroyMutex(context.mutex); SDL_DestroyRenderer(context.renderer); quit(0); return 0; }
/** * Thumbnailer main function. * return null if the thumbail generation failed. **/ jbyteArray Java_org_videolan_vlc_LibVLC_getThumbnail(JNIEnv *env, jobject thiz, jlong instance, jstring filePath, const jint frameWidth, const jint frameHeight) { libvlc_instance_t *libvlc = (libvlc_instance_t *)(intptr_t)instance; jbyteArray byteArray = NULL; /* Create the thumbnailer data structure */ thumbnailer_sys_t *sys = calloc(1, sizeof(thumbnailer_sys_t)); if (sys == NULL) { LOGE("Could not create the thumbnailer data structure!"); return NULL; } /* Initialize the barrier. */ pthread_mutex_init(&sys->doneMutex, NULL); pthread_cond_init(&sys->doneCondVar, NULL); /* Create a media player playing environment */ libvlc_media_player_t *mp = libvlc_media_player_new(libvlc); libvlc_media_t *m = new_media(instance, env, thiz, filePath, true, false); if (m == NULL) { LOGE("Could not create the media to play!"); goto end; } /* Fast and no options */ libvlc_media_add_option( m, ":no-audio" ); libvlc_media_add_option( m, ":no-spu" ); libvlc_media_add_option( m, ":no-osd" ); libvlc_media_player_set_media(mp, m); /* Get the size of the video with the tracks information of the media. */ libvlc_media_track_info_t *tracks; libvlc_media_parse(m); int nbTracks = libvlc_media_get_tracks_info(m, &tracks); libvlc_media_release(m); /* Parse the results */ unsigned videoWidth, videoHeight; bool hasVideoTrack = false; for (unsigned i = 0; i < nbTracks; ++i) if (tracks[i].i_type == libvlc_track_video) { videoWidth = tracks[i].u.video.i_width; videoHeight = tracks[i].u.video.i_height; hasVideoTrack = true; break; } free(tracks); /* Abort if we have not found a video track. */ if (!hasVideoTrack) { LOGE("Could not find any video track in this file.\n"); goto end; } /* VLC could not tell us the size */ if( videoWidth == 0 || videoHeight == 0 ) { LOGE("Could not find the video dimensions.\n"); goto end; } /* Compute the size parameters of the frame to generate. */ unsigned thumbWidth = frameWidth; unsigned thumbHeight = frameHeight; const float inputAR = (float)videoWidth / videoHeight; const float screenAR = (float)frameWidth / frameHeight; /* Most of the cases, video is wider than tall */ if (screenAR < inputAR) { thumbHeight = (float)frameWidth / inputAR + 1; sys->blackBorders = ( (frameHeight - thumbHeight) / 2 ) * frameWidth; } else { LOGD("Weird aspect Ratio.\n"); thumbWidth = (float)frameHeight * inputAR; sys->blackBorders = (frameWidth - thumbWidth) / 2; } sys->thumbPitch = thumbWidth * PIXEL_SIZE; sys->thumbHeight = thumbHeight; sys->frameWidth = frameWidth; /* Allocate the memory to store the frames. */ size_t thumbSize = sys->thumbPitch * (sys->thumbHeight+1); sys->thumbData = malloc(thumbSize); if (sys->thumbData == NULL) { LOGE("Could not allocate the memory to store the frame!"); goto end; } /* Allocate the memory to store the thumbnail. */ unsigned frameSize = frameWidth * frameHeight * PIXEL_SIZE; sys->frameData = calloc(frameSize, 1); if (sys->frameData == NULL) { LOGE("Could not allocate the memory to store the thumbnail!"); goto end; } /* Set the video format and the callbacks. */ libvlc_video_set_format(mp, "RGBA", thumbWidth, thumbHeight, sys->thumbPitch); libvlc_video_set_callbacks(mp, thumbnailer_lock, thumbnailer_unlock, NULL, (void*)sys); sys->state = THUMB_SEEKING; /* Play the media. */ libvlc_media_player_play(mp); libvlc_media_player_set_position(mp, THUMBNAIL_POSITION); int loops = 100; for (;;) { float pos = libvlc_media_player_get_position(mp); if (pos > THUMBNAIL_POSITION || !loops--) break; usleep(50000); } /* Wait for the thumbnail to be generated. */ pthread_mutex_lock(&sys->doneMutex); sys->state = THUMB_SEEKED; struct timespec deadline; clock_gettime(CLOCK_REALTIME, &deadline); deadline.tv_sec += 10; /* amount of seconds before we abort thumbnailer */ do { int ret = pthread_cond_timedwait(&sys->doneCondVar, &sys->doneMutex, &deadline); if (ret == ETIMEDOUT) break; } while (sys->state != THUMB_DONE); pthread_mutex_unlock(&sys->doneMutex); /* Stop and release the media player. */ libvlc_media_player_stop(mp); libvlc_media_player_release(mp); if (sys->state == THUMB_DONE) { /* Create the Java byte array to return the create thumbnail. */ byteArray = (*env)->NewByteArray(env, frameSize); if (byteArray == NULL) { LOGE("Could not allocate the Java byte array to store the frame!"); goto end; } (*env)->SetByteArrayRegion(env, byteArray, 0, frameSize, (jbyte *)sys->frameData); } end: pthread_mutex_destroy(&sys->doneMutex); pthread_cond_destroy(&sys->doneCondVar); free(sys->frameData); free(sys->thumbData); free(sys); return byteArray; }
/** * Thumbnailer main function. * return null if the thumbail generation failed. **/ jbyteArray Java_org_videolan_libvlc_util_VLCUtil_nativeGetThumbnail(JNIEnv *env, jobject thiz, jobject jmedia, const jint frameWidth, const jint frameHeight) { vlcjni_object *p_obj = VLCJniObject_getInstance(env, jmedia); jbyteArray byteArray = NULL; /* Create the thumbnailer data structure */ thumbnailer_sys_t *sys = calloc(1, sizeof(thumbnailer_sys_t)); if (sys == NULL) { LOGE("Could not create the thumbnailer data structure!"); goto enomem; } /* Initialize the barrier. */ pthread_mutex_init(&sys->doneMutex, NULL); pthread_cond_init(&sys->doneCondVar, NULL); /* Create a media player playing environment */ libvlc_media_player_t *mp = libvlc_media_player_new_from_media(p_obj->u.p_m); libvlc_media_player_set_video_title_display(mp, libvlc_position_disable, 0); /* Get the size of the video with the tracks information of the media. */ libvlc_media_track_t **tracks; libvlc_media_parse(p_obj->u.p_m); int nbTracks = libvlc_media_tracks_get(p_obj->u.p_m, &tracks); /* Parse the results */ unsigned videoWidth = 0, videoHeight = 0; bool hasVideoTrack = false; for (unsigned i = 0; i < nbTracks; ++i) if (tracks[i]->i_type == libvlc_track_video) { videoWidth = tracks[i]->video->i_width; videoHeight = tracks[i]->video->i_height; hasVideoTrack = true; break; } libvlc_media_tracks_release(tracks, nbTracks); /* Abort if we have not found a video track. */ if (!hasVideoTrack) { LOGE("Could not find any video track in this file.\n"); goto end; } LOGD("Video dimensions: %ix%i.\n", videoWidth, videoHeight ); /* VLC could not tell us the size */ if( videoWidth == 0 || videoHeight == 0 ) { LOGE("Could not find the video dimensions.\n"); goto end; } if( videoWidth < THUMBNAIL_MIN_WIDTH || videoHeight < THUMBNAIL_MIN_HEIGHT || videoWidth > THUMBNAIL_MAX_WIDTH || videoHeight > THUMBNAIL_MAX_HEIGHT ) { LOGE("Wrong video dimensions.\n"); goto end; } /* Compute the size parameters of the frame to generate. */ unsigned thumbWidth = frameWidth; unsigned thumbHeight = frameHeight; const float inputAR = (float)videoWidth / videoHeight; const float screenAR = (float)frameWidth / frameHeight; /* Most of the cases, video is wider than tall */ if (screenAR < inputAR) { thumbHeight = (float)frameWidth / inputAR + 1; sys->blackBorders = ( (frameHeight - thumbHeight) / 2 ) * frameWidth; } else { LOGD("Weird aspect Ratio.\n"); thumbWidth = (float)frameHeight * inputAR; sys->blackBorders = (frameWidth - thumbWidth) / 2; } sys->thumbPitch = thumbWidth * PIXEL_SIZE; sys->thumbHeight = thumbHeight; sys->frameWidth = frameWidth; /* Allocate the memory to store the frames. */ size_t thumbSize = sys->thumbPitch * (sys->thumbHeight+1); sys->thumbData = malloc(thumbSize); if (sys->thumbData == NULL) { LOGE("Could not allocate the memory to store the frame!"); goto end; } /* Allocate the memory to store the thumbnail. */ unsigned frameSize = frameWidth * frameHeight * PIXEL_SIZE; sys->frameData = calloc(frameSize, 1); if (sys->frameData == NULL) { LOGE("Could not allocate the memory to store the thumbnail!"); goto end; } /* Set the video format and the callbacks. */ libvlc_video_set_format(mp, "RGBA", thumbWidth, thumbHeight, sys->thumbPitch); libvlc_video_set_callbacks(mp, thumbnailer_lock, thumbnailer_unlock, NULL, (void*)sys); sys->state = THUMB_SEEKING; /* Play the media. */ libvlc_media_player_play(mp); libvlc_media_player_set_position(mp, THUMBNAIL_POSITION); const int wait_time = 50000; const int max_attempts = 100; for (int i = 0; i < max_attempts; ++i) { if (libvlc_media_player_is_playing(mp) && libvlc_media_player_get_position(mp) >= THUMBNAIL_POSITION) break; usleep(wait_time); } /* Wait for the thumbnail to be generated. */ pthread_mutex_lock(&sys->doneMutex); sys->state = THUMB_SEEKED; struct timespec deadline; clock_gettime(CLOCK_REALTIME, &deadline); deadline.tv_sec += 10; /* amount of seconds before we abort thumbnailer */ do { int ret = pthread_cond_timedwait(&sys->doneCondVar, &sys->doneMutex, &deadline); if (ret == ETIMEDOUT) break; } while (sys->state != THUMB_DONE); pthread_mutex_unlock(&sys->doneMutex); /* Stop and release the media player. */ libvlc_media_player_stop(mp); libvlc_media_player_release(mp); if (sys->state == THUMB_DONE) { /* Create the Java byte array to return the create thumbnail. */ byteArray = (*env)->NewByteArray(env, frameSize); if (byteArray == NULL) { LOGE("Could not allocate the Java byte array to store the frame!"); goto end; } (*env)->SetByteArrayRegion(env, byteArray, 0, frameSize, (jbyte *)sys->frameData); } end: pthread_mutex_destroy(&sys->doneMutex); pthread_cond_destroy(&sys->doneCondVar); free(sys->frameData); free(sys->thumbData); free(sys); enomem: return byteArray; }
int main(int argc, char *argv[]) { libvlc_instance_t *libvlc; libvlc_media_t *m; libvlc_media_player_t *mp; char const *vlc_argv[] = { "--no-audio", /* skip any audio track */ "--no-xlib", /* tell VLC to not use Xlib */ "--no-video-on-top", "--no-video-title-show", }; int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv); SDL_Surface *screen, *empty; SDL_Event event; SDL_Rect rect; int done = 0, action = 0, pause = 0, n = 0; struct ctx ctx; if(argc < 2) { printf("Usage: %s <filename>\n", argv[0]); return EXIT_FAILURE; } /* * Initialise libSDL */ if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) == -1) { printf("cannot initialize SDL\n"); return EXIT_FAILURE; } empty = SDL_CreateRGBSurface(SDL_SWSURFACE, VIDEOWIDTH, VIDEOHEIGHT, 32, 0, 0, 0, 0); ctx.surf = SDL_CreateRGBSurface(SDL_SWSURFACE, VIDEOWIDTH, VIDEOHEIGHT, 16, 0x001f, 0x07e0, 0xf800, 0); ctx.mutex = SDL_CreateMutex(); int options = SDL_ANYFORMAT | SDL_HWSURFACE | SDL_DOUBLEBUF; screen = SDL_SetVideoMode(WIDTH, HEIGHT, 0, options); if(!screen) { printf("cannot set video mode\n"); return EXIT_FAILURE; } /* * Initialise libVLC */ libvlc = libvlc_new(vlc_argc, vlc_argv); m = libvlc_media_new_path(libvlc, argv[1]); mp = libvlc_media_player_new_from_media(m); libvlc_media_release(m); libvlc_video_set_callbacks(mp, lock, unlock, display, &ctx); libvlc_video_set_format(mp, "RV16", VIDEOWIDTH, VIDEOHEIGHT, VIDEOWIDTH*2); libvlc_media_player_play(mp); /* * Main loop */ rect.w = 0; rect.h = 0; while(!done) { action = 0; /* Keys: enter (fullscreen), space (pause), escape (quit) */ while( SDL_PollEvent( &event ) ) { switch(event.type) { case SDL_QUIT: done = 1; break; case SDL_KEYDOWN: action = event.key.keysym.sym; break; } } switch(action) { case SDLK_ESCAPE: done = 1; break; case SDLK_RETURN: options ^= SDL_FULLSCREEN; screen = SDL_SetVideoMode(WIDTH, HEIGHT, 0, options); break; case ' ': pause = !pause; break; } //rect.x = (int)((1. + .5 * sin(0.03 * n)) * (WIDTH - VIDEOWIDTH) / 2); //rect.y = (int)((1. + .5 * cos(0.03 * n)) * (HEIGHT - VIDEOHEIGHT) / 2); rect.x = (int)(WIDTH - VIDEOWIDTH) / 2; rect.y = (int)(HEIGHT - VIDEOHEIGHT) / 2; if(!pause) n++; /* Blitting the surface does not prevent it from being locked and * written to by another thread, so we use this additional mutex. */ SDL_LockMutex(ctx.mutex); SDL_BlitSurface(ctx.surf, NULL, screen, &rect); SDL_UnlockMutex(ctx.mutex); SDL_Flip(screen); SDL_Delay(10); SDL_BlitSurface(empty, NULL, screen, &rect); } /* * Stop stream and clean up libVLC */ libvlc_media_player_stop(mp); libvlc_media_player_release(mp); libvlc_release(libvlc); /* * Close window and clean up libSDL */ SDL_DestroyMutex(ctx.mutex); SDL_FreeSurface(ctx.surf); SDL_FreeSurface(empty); SDL_Quit(); return 0; }
VlcVideoWidget::VlcVideoWidget(const QList<QByteArray> &args) : QFrame(0), vlcInstance_(0), vlcPlayer_(0), vlcMedia_(0), hasVideoOut_(false) { /// Convert the arguments into a proper form QVarLengthArray<const char*, 64> vlcArgs(args.size()); for (int i = 0; i < args.size(); ++i) vlcArgs[i] = args.at(i).constData(); // Create new libvlc instance vlcInstance_ = libvlc_new(vlcArgs.size(), vlcArgs.constData()); // Check if instance is running if (!vlcInstance_) { std::string errorMsg; if (libvlc_errmsg()) errorMsg = std::string("VlcVideoWidget: Failed to create VLC instance: ") + libvlc_errmsg(); else errorMsg = "VlcVideoWidget: Failed to create VLC instance"; LogError(errorMsg); return; } libvlc_set_user_agent(vlcInstance_, "realXtend Tundra Media Player 1.0", "Tundra/1.0"); /// Create the vlc player and set event callbacks vlcPlayer_ = libvlc_media_player_new(vlcInstance_); 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); /// register callbacks so that we can implement custom drawing of video frames libvlc_video_set_callbacks( vlcPlayer_, &CallBackLock, &CallBackUnlock, &CallBackDisplay, this); // Initialize rendering //idleLogo_ = QImage(":/images/vlc-cone.png"); idleLogo_ = QImage(":/images/play-video.png"); idleLogo_ = idleLogo_.convertToFormat(QImage::Format_ARGB32); //audioLogo_ = QImage(":/images/audio.png"); audioLogo_ = QImage(":/images/play-audio.png"); audioLogo_ = audioLogo_.convertToFormat(QImage::Format_ARGB32); pausePixmap_ = QPixmap(":/images/pause-big.png"); bufferingPixmap_ = QPixmap(":/images/buffering.png"); QSize startSize(600, 360); renderPixmap_ = QImage(startSize.width(), startSize.height(), QImage::Format_RGB32); libvlc_video_set_format(vlcPlayer_, "RV32", renderPixmap_.width(), renderPixmap_.height(), renderPixmap_.bytesPerLine()); // Initialize widget properties setMinimumSize(startSize); resize(startSize); setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); setStyleSheet("background-color: black;"); // Connect and start status poller connect(&pollTimer_, SIGNAL(timeout()), SLOT(StatusPoller())); pollTimer_.start(10); }
VideoStream::VideoStream(const std::string& uri, irr::video::IVideoDriver* const videoDriver, IrrIMGUI::IIMGUIHandle* const gui) : gui_{gui} { videoTexture_ = videoDriver->createImage(irr::video::ECF_A8R8G8B8, irr::core::dimension2du(1280, 720)); guiVideoTexture_ = gui_->createTexture(videoTexture_); char const *vlc_argv[] = { // "-I", "dummy", // Don't use any interface //"--ignore-config", // Don't use VLC's config "--no-audio", /* skip any audio track */ "--no-xlib", /* tell VLC to not use Xlib */ "--network-caching=4000", }; int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv); vlcInstance_ = libvlc_new(vlc_argc, vlc_argv); auto vlcMedia = libvlc_media_new_location(vlcInstance_, "http://iphone-streaming.ustream.tv/uhls/17074538/streams/live/iphone/playlist.m3u8"); vlcMediaPlayer_ = libvlc_media_player_new_from_media(vlcMedia); libvlc_media_release(vlcMedia); libvlc_video_set_callbacks(vlcMediaPlayer_, VideoStream::preRenderCallback, VideoStream::postRenderCallback, VideoStream::displayCallback, this); libvlc_video_set_format(vlcMediaPlayer_, "RV32", 1280, 720, videoTexture_->getPitch()); libvlc_media_player_play(vlcMediaPlayer_); }
int LibvlcCamera::PrimeCapture() { Info("Priming capture from %s", mPath.c_str()); mLibvlcInstance = libvlc_new (0, NULL); if(mLibvlcInstance == NULL) Fatal("Unable to create libvlc instance due to: %s", libvlc_errmsg()); mLibvlcMedia = libvlc_media_new_location(mLibvlcInstance, mPath.c_str()); if(mLibvlcMedia == NULL) Fatal("Unable to open input %s due to: %s", mPath.c_str(), libvlc_errmsg()); mLibvlcMediaPlayer = libvlc_media_player_new_from_media(mLibvlcMedia); if(mLibvlcMediaPlayer == NULL) Fatal("Unable to create player for %s due to: %s", mPath.c_str(), libvlc_errmsg()); libvlc_video_set_format(mLibvlcMediaPlayer, mTargetChroma.c_str(), width, height, width * mBpp); libvlc_video_set_callbacks(mLibvlcMediaPlayer, &LibvlcLockBuffer, &LibvlcUnlockBuffer, NULL, &mLibvlcData); mLibvlcData.bufferSize = width * height * mBpp; // Libvlc wants 32 byte alignment for images (should in theory do this for all image lines) mLibvlcData.buffer = (uint8_t*)zm_mallocaligned(32, mLibvlcData.bufferSize); mLibvlcData.prevBuffer = (uint8_t*)zm_mallocaligned(32, mLibvlcData.bufferSize); mLibvlcData.newImage.setValueImmediate(false); libvlc_media_player_play(mLibvlcMediaPlayer); return(0); }