void VLCWrapperImpl::OpenMedia(const char* pszMediaPathName)
{
// Load a new item
m_pMedia = libvlc_media_new (m_pVLCInstance, pszMediaPathName, &m_VLCex);
libvlc_media_player_set_media (m_pMediaPlayer, m_pMedia, &m_VLCex);
ProcessVLCException(&m_VLCex, m_EH);
}
int main(int argc, char* argv[])
{
const char * const vlc_args[] = {
"-I", "dummy", /* Don't use any interface */
"--ignore-config", /* Don't use VLC's config */
"--plugin-path=/set/your/path/to/libvlc/module/if/you/are/on/windows/or/macosx" };
libvlc_exception_t ex;
libvlc_instance_t * inst;
libvlc_media_player_t *mp;
libvlc_media_t *m;
libvlc_exception_init (&ex);
/* init vlc modules, should be done only once */
inst = libvlc_new (sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args, &ex);
raise (&ex);
/* Create a new item */
m = libvlc_media_new (inst, "http://mycool.movie.com/test.mov", &ex);
raise (&ex);
/* XXX: demo art and meta information fetching */
/* Create a media player playing environement */
mp = libvlc_media_player_new_from_media (m, &ex);
raise (&ex);
/* No need to keep the media now */
libvlc_media_release (m);
#if 0
/* This is a non working code that show how to hooks into a window,
* if we have a window around */
libvlc_drawable_t drawable = xdrawable;
/* or on windows */
libvlc_drawable_t drawable = hwnd;
libvlc_media_player_set_drawable (mp, drawable, &ex);
raise (&ex);
#endif
/* play the media_player */
libvlc_media_player_play (mp, &ex);
raise (&ex);
sleep (10); /* Let it play a bit */
/* Stop playing */
#warning There is known deadlock bug here. Please update to LibVLC 1.1!
libvlc_media_player_stop (mp, &ex);
/* Free the media_player */
libvlc_media_player_release (mp);
libvlc_release (inst);
raise (&ex);
return 0;
}
/*
* Known issues: since moving in the playlist using playlist_Next
* or playlist_Prev implies starting to play items, the a_position
* argument will be only honored for the 1st item in the list.
*
* XXX:FIXME split moving in the playlist and playing items two
* different actions or make playlist_<Next|Prev> accept a time
* value to start to play from.
*/
void
mediacontrol_start( mediacontrol_Instance *self,
const mediacontrol_Position * a_position,
mediacontrol_Exception *exception )
{
libvlc_media_t * p_media;
char * psz_name;
libvlc_exception_t ex;
mediacontrol_exception_init( exception );
libvlc_exception_init( &ex );
p_media = libvlc_media_player_get_media( self->p_media_player, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
if ( ! p_media )
{
/* No media was defined. */
RAISE( mediacontrol_PlaylistException, "No defined media." );
}
else
{
/* A media was defined. Get its mrl to reuse it, but reset the options
(because start-time may have been set on the previous invocation */
psz_name = libvlc_media_get_mrl( p_media, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
/* Create a new media */
p_media = libvlc_media_new( self->p_instance, psz_name, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
if( a_position->value )
{
char * psz_from;
libvlc_time_t i_from;
/* A start position was specified. Add it to media options */
psz_from = ( char * )malloc( 20 * sizeof( char ) );
i_from = private_mediacontrol_position2microsecond( self->p_media_player, a_position ) / 1000000;
snprintf( psz_from, 20, "start-time=%"PRId64, i_from );
libvlc_media_add_option( p_media, psz_from, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
}
libvlc_media_player_set_media( self->p_media_player, p_media, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
libvlc_media_player_play( self->p_media_player, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
}
}
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;
}
void
mediacontrol_set_mrl( mediacontrol_Instance *self,
const char * psz_file,
mediacontrol_Exception *exception )
{
libvlc_media_t * p_media;
libvlc_exception_t ex;
mediacontrol_exception_init( exception );
libvlc_exception_init( &ex );
p_media = libvlc_media_new( self->p_instance, psz_file, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
libvlc_media_player_set_media( self->p_media_player, p_media, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
}
int VlcPlugin::playlist_add( const char *mrl, libvlc_exception_t *ex )
{
int item = -1;
libvlc_media_t *p_m = libvlc_media_new(libvlc_instance,mrl,ex);
if( libvlc_exception_raised(ex) )
return -1;
libvlc_media_list_lock(libvlc_media_list);
libvlc_media_list_add_media(libvlc_media_list,p_m,ex);
if( !libvlc_exception_raised(ex) )
item = libvlc_media_list_count(libvlc_media_list,ex)-1;
libvlc_media_list_unlock(libvlc_media_list);
libvlc_media_release(p_m);
return item;
}
int VlcPlugin::playlist_add_extended_untrusted( const char *mrl, const char *name,
int optc, const char **optv, libvlc_exception_t *ex )
{
libvlc_media_t *p_m = libvlc_media_new(libvlc_instance, mrl,ex);
int item = -1;
if( libvlc_exception_raised(ex) )
return -1;
for( int i = 0; i < optc; ++i )
libvlc_media_add_option_flag(p_m, optv[i], libvlc_media_option_unique);
libvlc_media_list_lock(libvlc_media_list);
libvlc_media_list_add_media(libvlc_media_list,p_m,ex);
if( !libvlc_exception_raised(ex) )
item = libvlc_media_list_count(libvlc_media_list,ex)-1;
libvlc_media_list_unlock(libvlc_media_list);
libvlc_media_release(p_m);
return item;
}
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;
}
static void
clutter_vlc_set_uri(ClutterVlcVideoTexture* video_texture,
const gchar* uri)
{
ClutterVlcVideoTexturePrivate* priv;
GObject* self;
libvlc_media_t* vlc_media;
libvlc_event_manager_t* vlc_event_manager;
char media_arg[96];
priv = video_texture->priv;
self = G_OBJECT(video_texture);
if (priv->vlc_instance == NULL)
return;
if (priv->vlc_media_player != NULL)
{
libvlc_state_t state;
state = libvlc_media_player_get_state(priv->vlc_media_player,
&priv->vlc_exception);
clutter_vlc_catch(&priv->vlc_exception);
if (state == libvlc_Opening || state == libvlc_Buffering ||
state == libvlc_Forward || state == libvlc_Backward ||
state == libvlc_Playing)
{
libvlc_media_player_stop(priv->vlc_media_player, &priv->vlc_exception);
clutter_vlc_catch(&priv->vlc_exception);
}
libvlc_media_player_release(priv->vlc_media_player);
priv->vlc_media_player = NULL;
g_source_remove(priv->tick_timeout_id);
priv->tick_timeout_id = 0;
}
if (priv->uri != NULL)
{
g_free(priv->uri);
priv->uri = NULL;
}
priv->is_eos = FALSE;
if (uri != NULL)
{
priv->uri = g_strdup(uri);
if (priv->uri == NULL)
return;
vlc_media = libvlc_media_new(priv->vlc_instance,
priv->uri, &priv->vlc_exception);
clutter_vlc_catch(&priv->vlc_exception);
sprintf(media_arg, ":clutter-texture=%lld",
(long long int)(intptr_t)CLUTTER_TEXTURE(video_texture));
libvlc_media_add_option(vlc_media, media_arg, &priv->vlc_exception);
clutter_vlc_catch(&priv->vlc_exception);
priv->vlc_media_player =
libvlc_media_player_new_from_media(vlc_media,
&priv->vlc_exception);
clutter_vlc_catch(&priv->vlc_exception);
libvlc_media_release(vlc_media);
vlc_event_manager =
libvlc_media_player_event_manager(priv->vlc_media_player,
&priv->vlc_exception);
clutter_vlc_catch(&priv->vlc_exception);
libvlc_event_attach(vlc_event_manager, libvlc_MediaPlayerEndReached,
clutter_vlc_event_handler, video_texture,
&priv->vlc_exception);
clutter_vlc_catch(&priv->vlc_exception);
priv->tick_timeout_id = g_timeout_add(TICK_TIMEOUT * 1000,
clutter_vlc_tick_timeout,
video_texture);
}
g_object_notify(self, "uri");
g_object_notify(self, "can-seek");
g_object_notify(self, "duration");
g_object_notify(self, "progress");
}
void VLCAudioPlayer::open(QString filename)
{
libvlc_media_t *m = libvlc_media_new(inst, filename.toStdString().c_str(), &vlc_ex);
libvlc_media_player_set_media(mediaPlayer, m, &vlc_ex);
libvlc_media_release(m);
}
Omm::AvStream::Meta*
VlcTagger::tag(const std::string& uri)
{
LOGNS(Omm::Av, upnpav, debug, "vlc tagger tagging: " + uri);
VlcMeta* pMeta = new VlcMeta;
#if LIBVLC_VERSION_INT < 0x110
_pVlcMedia = libvlc_media_new(_pVlcInstance, uri.c_str(), _pException);
#else
_pVlcMedia = libvlc_media_new_location(_pVlcInstance, uri.c_str());
#endif
handleException();
#if LIBVLC_VERSION_INT < 0x110
#else
libvlc_media_parse(_pVlcMedia);
#endif
#if LIBVLC_VERSION_INT < 0x110
char* pTitle = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Title, _pException);
#else
char* pTitle = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Title);
#endif
handleException();
if (pTitle) {
pMeta->setTag("title", std::string(pTitle));
}
#if LIBVLC_VERSION_INT < 0x110
char* pArtist = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Artist, _pException);
#else
char* pArtist = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Artist);
#endif
handleException();
if (pArtist) {
pMeta->setTag("artist", std::string(pArtist));
}
#if LIBVLC_VERSION_INT < 0x110
char* pAlbum = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Album, _pException);
#else
char* pAlbum = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_Album);
#endif
handleException();
if (pAlbum) {
pMeta->setTag("album", std::string(pAlbum));
}
#if LIBVLC_VERSION_INT < 0x110
char* pTrack = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_TrackNumber, _pException);
#else
char* pTrack = libvlc_media_get_meta(_pVlcMedia, libvlc_meta_TrackNumber);
#endif
handleException();
if (pTrack) {
pMeta->setTag("track", std::string(pTrack));
}
#if LIBVLC_VERSION_INT < 0x110
libvlc_time_t duration = libvlc_media_get_duration(_pVlcMedia, _pException);
#else
libvlc_time_t duration = libvlc_media_get_duration(_pVlcMedia);
#endif
handleException();
if (duration) {
pMeta->setTag("duration", Poco::NumberFormatter::format(duration));
}
libvlc_media_release(_pVlcMedia);
// vlc libs need to play the data in order to analyse the streams
// thus we make a simple filename based media type detection
Poco::Path path(uri);
// try to get a filename extension for type of media
std::string extension = Poco::toLower(path.getExtension());
// LOGNS(Omm::Av, upnpav, debug, "vlc tagger extension: " + extension);
Omm::AvStream::Meta::ContainerFormat containerFormat = Omm::AvStream::Meta::CF_UNKNOWN;
if (extension == "mp3") {
pMeta->_mime = Omm::Av::Mime::AUDIO_MPEG;
containerFormat = Omm::AvStream::Meta::CF_AUDIO;
}
else if (extension == "wma" || extension == "ogg" || extension == "wav") {
pMeta->_mime = Omm::Av::Mime::TYPE_AUDIO;
containerFormat = Omm::AvStream::Meta::CF_AUDIO;
}
else if (extension == "mp4" || extension == "mpeg" || extension == "mpg") {
pMeta->_mime = Omm::Av::Mime::VIDEO_MPEG;
containerFormat = Omm::AvStream::Meta::CF_VIDEO;
}
else if (extension == "avi" || extension == "wmv" || extension == "flv") {
pMeta->_mime = Omm::Av::Mime::TYPE_VIDEO;
containerFormat = Omm::AvStream::Meta::CF_VIDEO;
}
else if (extension == "jpg" || extension == "png" || extension == "gif") {
pMeta->_mime = Omm::Av::Mime::TYPE_IMAGE;
containerFormat = Omm::AvStream::Meta::CF_IMAGE;
}
else if (extension == "m3u") {
pMeta->_mime = Omm::Av::Mime::PLAYLIST;
containerFormat = Omm::AvStream::Meta::CF_PLAYLIST;
}
if (containerFormat == Omm::AvStream::Meta::CF_AUDIO) {
pMeta->_isStillImage = false;
VlcStreamInfo* pStreamInfo = new VlcStreamInfo;
pStreamInfo->_isAudio = true;
pStreamInfo->_isVideo = false;
pMeta->addStream(pStreamInfo);
}
else if (containerFormat == Omm::AvStream::Meta::CF_VIDEO) {
pMeta->_isStillImage = false;
VlcStreamInfo* pStreamInfo = new VlcStreamInfo;
pStreamInfo->_isAudio = false;
pStreamInfo->_isVideo = true;
pMeta->addStream(pStreamInfo);
}
else if (containerFormat == Omm::AvStream::Meta::CF_IMAGE) {
pMeta->_isStillImage = true;
VlcStreamInfo* pStreamInfo = new VlcStreamInfo;
pStreamInfo->_isAudio = false;
pStreamInfo->_isVideo = false;
pMeta->addStream(pStreamInfo);
}
else if (containerFormat == Omm::AvStream::Meta::CF_PLAYLIST) {
pMeta->setIsPlaylist(true);
}
return pMeta;
}