libvlc_media_t *new_media(jlong instance, JNIEnv *env, jobject thiz, jstring fileLocation, bool noOmx, bool noVideo) { libvlc_instance_t *libvlc = (libvlc_instance_t*)(intptr_t)instance; jboolean isCopy; const char *psz_location = (*env)->GetStringUTFChars(env, fileLocation, &isCopy); libvlc_media_t *p_md = libvlc_media_new_location(libvlc, psz_location); (*env)->ReleaseStringUTFChars(env, fileLocation, psz_location); if (!p_md) return NULL; if (!noOmx) { jclass cls = (*env)->GetObjectClass(env, thiz); jmethodID methodId = (*env)->GetMethodID(env, cls, "getHardwareAcceleration", "()I"); int hardwareAcceleration = (*env)->CallIntMethod(env, thiz, methodId); if (hardwareAcceleration == HW_ACCELERATION_DECODING || hardwareAcceleration == HW_ACCELERATION_FULL) { /* * Set higher caching values if using iomx decoding, since some omx * decoders have a very high latency, and if the preroll data isn't * enough to make the decoder output a frame, the playback timing gets * started too soon, and every decoded frame appears to be too late. * On Nexus One, the decoder latency seems to be 25 input packets * for 320x170 H.264, a few packets less on higher resolutions. * On Nexus S, the decoder latency seems to be about 7 packets. */ libvlc_media_add_option(p_md, ":file-caching=1500"); libvlc_media_add_option(p_md, ":network-caching=1500"); libvlc_media_add_option(p_md, ":codec=mediacodec,iomx,all"); } if (noVideo) libvlc_media_add_option(p_md, ":no-video"); } return p_md; }
// Initialization bool MediaPlayer::initialize( const std::string &url ) { LDEBUG( "vlc", "Initialize: url=%s", url.c_str() ); // Create media from url libvlc_media_t *m=libvlc_media_new_path( instance(), url.c_str() ); if (!m) { LERROR( "vlc", "Cannot initialize new media from url: url=%s", url.c_str() ); return false; } // Add common parameters libvlc_media_add_option( m, "verbose=1000" ); libvlc_media_add_option( m, "no-osd" ); libvlc_media_add_option( m, "ffmpeg-hw" ); // Create a media player playing environement _mp = libvlc_media_player_new_from_media(m); if (!_mp) { libvlc_media_release (m); LERROR( "vlc", "Cannot create media player from url: url=%s", url.c_str() ); return false; } // No need to keep the media now libvlc_media_release (m); { // Set WindowID VideoDescription desc; if (getVideoDescription( desc )) { #ifndef _WIN32 libvlc_media_player_set_xwindow( _mp, desc.winID ); #else libvlc_media_player_set_hwnd( _mp, desc ); #endif } } { // Attach to stop asyn events libvlc_event_manager_t *mgr=libvlc_media_player_event_manager( _mp ); libvlc_event_attach( mgr, libvlc_MediaPlayerEndReached, vlcCallback, this ); } return true; }
// retorna true si es un video, false en caso contrario // Si es un video ademas rellena los parametros Tiempo, nAncho y nAlto const bool InformacionArchivoEx::_AnalisisVLC(const TCHAR *Path, UINT64 &Tiempo, UINT &nAncho, UINT &nAlto, libvlc_instance_t *Instancia) { char Destino[2049]; size_t TamnTexto = wcslen(Path); int TamRes = WideCharToMultiByte(CP_UTF8, NULL, Path, TamnTexto, Destino, 2048, NULL, NULL); Destino[TamRes] = 0; libvlc_media_t *Media = NULL; libvlc_media_player_t *nMediaPlayer = NULL; Media = libvlc_media_new_path(Instancia, Destino); libvlc_media_parse(Media); libvlc_media_add_option(Media, "sout=#description:dummy"); nMediaPlayer = libvlc_media_player_new_from_media(Media); libvlc_state_t Estado = libvlc_Opening; libvlc_media_player_play(nMediaPlayer); //posible deadlock // Esperamos hasta que empieze el play while (Estado != libvlc_Playing && Estado != libvlc_Ended) { Estado = libvlc_media_player_get_state(nMediaPlayer); Sleep(100); if (Estado == libvlc_Error) { // Hay un error en la libvlc, salimos Sleep(300); // Nos aseguramos de que el log se escriba libvlc_media_player_stop(nMediaPlayer); libvlc_media_release(Media); libvlc_media_player_release(nMediaPlayer); Tiempo = 0; nAncho = 0; nAlto = 0; return false; } } // Miramos los streams disponibles y buscamos el de video libvlc_media_track_info_t *TI = NULL; int z = libvlc_media_get_tracks_info(Media, &TI); for (int n = 0; n < z; n++) { if (TI->i_type == libvlc_track_video) { libvlc_media_player_stop(nMediaPlayer); Tiempo = 0; //libvlc_media_player_get_length(nMediaPlayer); // NO DA BIEN EL TIEMPO.............. nAncho = TI->u.video.i_width; nAlto = TI->u.video.i_height; libvlc_media_release(Media); libvlc_media_player_release(nMediaPlayer); return true; } TI ++; } libvlc_media_release(Media); libvlc_media_player_release(nMediaPlayer); // No hay streams de video retornamos false Tiempo = 0; nAncho = 0; nAlto = 0; return false; }
void SMActionVideoVLC::setRepeat(int r) { _repeat = r; if (_m) { QString options = "input-repeat="; options += QString::number(repeat()); libvlc_media_add_option(_m, options.toLatin1()); } }
static void add_media_options(libvlc_media_t *p_md, JNIEnv *env, jobjectArray mediaOptions) { int stringCount = (*env)->GetArrayLength(env, mediaOptions); for(int i = 0; i < stringCount; i++) { jstring option = (jstring)(*env)->GetObjectArrayElement(env, mediaOptions, i); const char* p_st = (*env)->GetStringUTFChars(env, option, 0); libvlc_media_add_option(p_md, p_st); // option (*env)->ReleaseStringUTFChars(env, option, p_st); } }
void Java_org_videolan_libvlc_MediaList_loadPlaylist(JNIEnv *env, jobject thiz, jobject libvlcJava, jstring mrl, jobject items) { const char* p_mrl = (*env)->GetStringUTFChars(env, mrl, NULL); libvlc_media_t *p_md = libvlc_media_new_location((libvlc_instance_t*)(intptr_t)getLong(env, libvlcJava, "mLibVlcInstance"), p_mrl); libvlc_media_add_option(p_md, ":demux=playlist,none"); libvlc_media_add_option(p_md, ":run-time=1"); struct stopped_monitor* monitor = malloc(sizeof(struct stopped_monitor)); pthread_mutex_init(&monitor->doneMutex, NULL); pthread_cond_init(&monitor->doneCondVar, NULL); monitor->stopped = false; pthread_mutex_lock(&monitor->doneMutex); libvlc_media_player_t* p_mp = libvlc_media_player_new((libvlc_instance_t*)(intptr_t)getLong(env, libvlcJava, "mLibVlcInstance")); libvlc_media_player_set_video_title_display(p_mp, libvlc_position_disable, 0); libvlc_event_manager_t* ev = libvlc_media_player_event_manager(p_mp); libvlc_event_attach(ev, libvlc_MediaPlayerEndReached, stopped_callback, monitor); libvlc_media_player_set_media(p_mp, p_md); libvlc_media_player_play(p_mp); struct timespec deadline; clock_gettime(CLOCK_REALTIME, &deadline); deadline.tv_sec += 2; /* If "VLC can't open the file", return */ int mp_alive = 1; while(!(monitor->stopped) && mp_alive) { pthread_cond_timedwait(&monitor->doneCondVar, &monitor->doneMutex, &deadline); mp_alive = libvlc_media_player_will_play(p_mp); } pthread_mutex_unlock(&monitor->doneMutex); pthread_mutex_destroy(&monitor->doneMutex); pthread_cond_destroy(&monitor->doneCondVar); free(monitor); libvlc_media_player_release(p_mp); expand_media_internal(env, (libvlc_instance_t*)(intptr_t)getLong(env, libvlcJava, "mLibVlcInstance"), items, p_md); (*env)->ReleaseStringUTFChars(env, mrl, p_mrl); }
/* * 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; }
static void xmr_player_set_repeat(XmrPlayer *player) { libvlc_media_t *media; gchar *option; media = libvlc_media_player_get_media(player->priv->player); if (media == NULL) return ; option = g_strdup_printf("input-repeat=%d", player->priv->loop_count); libvlc_media_add_option(media, option); g_free(option); }
void SMActionVideoVLC::load(int time) { if (!isLoaded()) { SMAction::load(time);qInfo() << mediaVLC(); _m = libvlc_media_new_path(_vlcinstance, mediaVLC()); if (!_m) { setStatus(STATUS_ERROR); setLoadStatus(STATUS_ERROR); return; } libvlc_media_player_set_media (_mp, _m); QString options = "input-repeat="; options += QString::number(repeat()); libvlc_media_add_option(_m, options.toLatin1()); setLoadStatus(STATUS_LOADED); } }
static void test_media_subitems_media(libvlc_media_t *media, bool play) { libvlc_media_add_option(media, ":ignore-filetypes= "); bool subitems_found[TEST_SUBITEMS_COUNT] = { 0 }; vlc_sem_t sem; vlc_sem_init (&sem, 0); libvlc_event_manager_t *em = libvlc_media_event_manager (media); libvlc_event_attach (em, libvlc_MediaSubItemTreeAdded, subitem_tree_added, &sem); libvlc_event_attach (em, libvlc_MediaSubItemAdded, subitem_added, subitems_found); if (play) { /* XXX: libvlc_media_parse_async won't work with fd, since it won't be * preparsed because fd:// is an unknown type, so play the file to * force parsing. */ libvlc_media_player_t *mp = libvlc_media_player_new_from_media (media); assert (mp); assert (libvlc_media_player_play (mp) != -1); vlc_sem_wait (&sem); libvlc_media_player_release (mp); } else { libvlc_media_parse_async (media); vlc_sem_wait (&sem); } vlc_sem_destroy (&sem); for (unsigned i = 0; i < TEST_SUBITEMS_COUNT; ++i) { log ("test if %s was added\n", test_media_subitems_list[i].file); assert (subitems_found[i]); } }
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; }
void Java_org_videolan_libvlc_LibVLC_playMRL(JNIEnv *env, jobject thiz, jlong instance, jstring mrl, jobjectArray mediaOptions) { /* Release previous media player, if any */ releaseMediaPlayer(env, thiz); /* Create a media player playing environment */ libvlc_media_player_t *mp = libvlc_media_player_new((libvlc_instance_t*)(intptr_t)instance); libvlc_media_player_set_video_title_display(mp, libvlc_position_disable, 0); jobject myJavaLibVLC = (*env)->NewGlobalRef(env, thiz); //if AOUT_AUDIOTRACK_JAVA, we use amem jclass cls = (*env)->GetObjectClass(env, thiz); jmethodID methodId = (*env)->GetMethodID(env, cls, "getAout", "()I"); if ( (*env)->CallIntMethod(env, thiz, methodId) == AOUT_AUDIOTRACK_JAVA ) { libvlc_audio_set_callbacks(mp, aout_play, aout_pause, NULL, NULL, NULL, (void*) myJavaLibVLC); libvlc_audio_set_format_callbacks(mp, aout_open, aout_close); } /* Connect the event manager */ libvlc_event_manager_t *ev = libvlc_media_player_event_manager(mp); static const libvlc_event_type_t mp_events[] = { libvlc_MediaPlayerPlaying, libvlc_MediaPlayerPaused, libvlc_MediaPlayerEndReached, libvlc_MediaPlayerStopped, libvlc_MediaPlayerVout, libvlc_MediaPlayerPositionChanged, libvlc_MediaPlayerEncounteredError }; for(int i = 0; i < (sizeof(mp_events) / sizeof(*mp_events)); i++) libvlc_event_attach(ev, mp_events[i], vlc_event_callback, myVm); /* Keep a pointer to this media player */ setLong(env, thiz, "mInternalMediaPlayerInstance", (jlong)(intptr_t)mp); cls = (*env)->GetObjectClass(env, thiz); jmethodID methodID = (*env)->GetMethodID(env, cls, "applyEqualizer", "()V"); (*env)->CallVoidMethod(env, thiz, methodID); const char* p_mrl = (*env)->GetStringUTFChars(env, mrl, 0); libvlc_media_t* p_md = libvlc_media_new_location((libvlc_instance_t*)(intptr_t)instance, p_mrl); /* media options */ if (mediaOptions != NULL) { int stringCount = (*env)->GetArrayLength(env, mediaOptions); for(int i = 0; i < stringCount; i++) { jstring option = (jstring)(*env)->GetObjectArrayElement(env, mediaOptions, i); const char* p_st = (*env)->GetStringUTFChars(env, option, 0); libvlc_media_add_option(p_md, p_st); // option (*env)->ReleaseStringUTFChars(env, option, p_st); } } (*env)->ReleaseStringUTFChars(env, mrl, p_mrl); /* Connect the media event manager. */ libvlc_event_manager_t *ev_media = libvlc_media_event_manager(p_md); static const libvlc_event_type_t mp_media_events[] = { libvlc_MediaParsedChanged }; for(int i = 0; i < (sizeof(mp_media_events) / sizeof(*mp_media_events)); i++) libvlc_event_attach(ev_media, mp_media_events[i], vlc_event_callback, myVm); libvlc_media_player_set_media(mp, p_md); libvlc_media_player_play(mp); }
int main(int argc, char **argv) { // having these declarations at the start of the function is only needed for C compatibility int i; char *path; char **vlc_argv; char *soutOption; int nr; libvlc_instance_t *vlc; libvlc_media_t *media; libvlc_media_player_t *player; libvlc_event_manager_t *eventManager; // init arguments if(argc < 3) { printf(ENDLN("Usage: vlcwrapper <input> <soutstring> [optional vlc arguments]")); return 1; } // print some information path = argv[1]; fprintf(stdout, ENDLN("I VLCWrapper version %s, using VLC %s"), VERSION, libvlc_get_version()); fprintf(stdout, ENDLN("A path %s"), path); fprintf(stdout, ENDLN("A config %s"), argv[2]); // init state machine global_state = STATE_NULL; // arguments (you shouldn't need these in normal usage; but we don't support all arguments by ourself yet) nr = argc - 3; vlc_argv = (char**)malloc(sizeof(char*)*nr); for(i = 3; i < argc; i++) { vlc_argv[i-3] = (char*)malloc(sizeof(char)* (strlen(argv[i]) + 1)); strcpy(vlc_argv[i-3], argv[i]); } for(i = 0; i < nr; i++) fprintf(stdout, ENDLN("A cmd %d %s"), i, vlc_argv[i]); // init vlc vlc = libvlc_new(nr, vlc_argv); libvlc_set_user_agent(vlc, USER_AGENT, HTTP_USER_AGENT); // create media and set sout string media = libvlc_media_new_path(vlc, path); soutOption = (char*)malloc(strlen(argv[2]) * sizeof(char) + 6); snprintf(soutOption, strlen(argv[2]) + 6, "sout=%s", argv[2]); libvlc_media_add_option(media, soutOption); // create player and listen for events player = libvlc_media_player_new_from_media(media); eventManager = libvlc_media_player_event_manager(player); register_event(eventManager, libvlc_MediaPlayerPlaying, STATE_PLAYING); register_event(eventManager, libvlc_MediaPlayerEncounteredError, STATE_ERROR); register_event(eventManager, libvlc_MediaPlayerEndReached, STATE_FINISHED); // start playing it libvlc_media_player_play(player); // wait till it's started or stopped because of an error while(global_state != STATE_ERROR && global_state != STATE_PLAYING) millisleep(100); // let it play till it has finished, while printing status information while(global_state == STATE_PLAYING) { fprintf(stdout, ENDLN("P %d"), libvlc_media_player_get_time(player)); fflush(stdout); millisleep(LOG_INTERVAL); } // stop playing libvlc_media_player_stop(player); // release objects in memory libvlc_media_release(media); libvlc_media_player_release(player); libvlc_release(vlc); return 0; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError"); qRegisterMetaType<CatchChallenger::Chat_type>("CatchChallenger::Chat_type"); qRegisterMetaType<CatchChallenger::Player_type>("CatchChallenger::Player_type"); qRegisterMetaType<QList<RssNews::RssEntry> >("QList<RssNews::RssEntry>"); realSslSocket=new QSslSocket(); haveFirstHeader=false; socket=NULL; realSslSocket=NULL; CatchChallenger::Api_client_real::client=NULL; ui->setupUi(this); ui->update->setVisible(false); ui->news->setVisible(false); server_name=SERVER_NAME; server_dns_or_ip=SERVER_DNS_OR_IP; server_port=SERVER_PORT; QString settingsServerPath=QCoreApplication::applicationDirPath()+QStringLiteral("/server.conf"); if(QFile(settingsServerPath).exists()) { QSettings settingsServer(settingsServerPath,QSettings::IniFormat); if(settingsServer.contains(QStringLiteral("server_dns_or_ip")) && settingsServer.contains(QStringLiteral("server_port")) && settingsServer.contains(QStringLiteral("proxy_port"))) { bool ok,ok2; quint16 server_port_temp=settingsServer.value(QStringLiteral("server_port")).toString().toUShort(&ok); quint16 proxy_port_temp=settingsServer.value(QStringLiteral("proxy_port")).toString().toUShort(&ok2); if(settingsServer.value(QStringLiteral("server_dns_or_ip")).toString().contains(QRegularExpression(QStringLiteral("^([a-zA-Z0-9]{8}\\.onion|.*\\.i2p)$"))) && ok && ok2 && server_port_temp>0 && proxy_port_temp>0) { server_name=tr("Hidden server"); if(settingsServer.contains(QStringLiteral("server_name"))) server_name=settingsServer.value(QStringLiteral("server_name")).toString(); server_dns_or_ip=settingsServer.value(QStringLiteral("server_dns_or_ip")).toString(); proxy_dns_or_ip=QStringLiteral("localhost"); server_port=server_port_temp; proxy_port=proxy_port_temp; if(settingsServer.contains(QStringLiteral("proxy_dns_or_ip"))) proxy_dns_or_ip=settingsServer.value(QStringLiteral("proxy_dns_or_ip")).toString(); ui->label_login_register->setStyleSheet(ui->label_login_register->styleSheet()+QStringLiteral("text-decoration:line-through;")); ui->label_login_website->setStyleSheet(ui->label_login_website->styleSheet()+QStringLiteral("text-decoration:line-through;")); ui->label_login_register->setText(tr("Register")); ui->label_login_website->setText(tr("Web site")); } } } InternetUpdater::internetUpdater=new InternetUpdater(); connect(InternetUpdater::internetUpdater,&InternetUpdater::newUpdate,this,&MainWindow::newUpdate); RssNews::rssNews=new RssNews(); connect(RssNews::rssNews,&RssNews::rssEntryList,this,&MainWindow::rssEntryList); CatchChallenger::BaseWindow::baseWindow=new CatchChallenger::BaseWindow(); ui->stackedWidget->addWidget(CatchChallenger::BaseWindow::baseWindow); { serverLoginList.clear(); if(settings.contains(QStringLiteral("login"))) { const QStringList &loginList=settings.value("login").toStringList(); int index=0; while(index<loginList.size()) { if(settings.contains(loginList.at(index))) serverLoginList[loginList.at(index)]=settings.value(loginList.at(index)).toString(); else serverLoginList[loginList.at(index)]=QString(); index++; } if(!loginList.isEmpty()) ui->lineEditLogin->setText(loginList.first()); else ui->lineEditLogin->setText(QString()); } else ui->lineEditLogin->setText(QString()); if(serverLoginList.contains(ui->lineEditLogin->text())) ui->lineEditPass->setText(serverLoginList.value(ui->lineEditLogin->text())); else ui->lineEditPass->setText(QString()); ui->checkBoxRememberPassword->setChecked(!ui->lineEditPass->text().isEmpty()); } connect(&updateTheOkButtonTimer,&QTimer::timeout,this,&MainWindow::updateTheOkButton); stopFlood.setSingleShot(false); stopFlood.start(1500); updateTheOkButtonTimer.setSingleShot(false); updateTheOkButtonTimer.start(1000); numberForFlood=0; haveShowDisconnectionReason=false; ui->stackedWidget->addWidget(CatchChallenger::BaseWindow::baseWindow); connect(CatchChallenger::BaseWindow::baseWindow,&CatchChallenger::BaseWindow::newError,this,&MainWindow::newError,Qt::QueuedConnection); stateChanged(QAbstractSocket::UnconnectedState); setWindowTitle(QStringLiteral("CatchChallenger - ")+server_name); vlcPlayer=NULL; if(Audio::audio.vlcInstance!=NULL) { if(QFile(QCoreApplication::applicationDirPath()+QStringLiteral("/music/loading.ogg")).exists()) { // Create a new Media const QString &musicPath=QDir::toNativeSeparators(QCoreApplication::applicationDirPath()+QStringLiteral("/music/loading.ogg")); libvlc_media_t *vlcMedia = libvlc_media_new_path(Audio::audio.vlcInstance, musicPath.toUtf8().constData()); if(vlcMedia!=NULL) { // Create a new libvlc player vlcPlayer = libvlc_media_player_new_from_media(vlcMedia); if(vlcPlayer!=NULL) { // Get event manager for the player instance libvlc_event_manager_t *manager = libvlc_media_player_event_manager(vlcPlayer); // Attach the event handler to the media player error's events libvlc_event_attach(manager,libvlc_MediaPlayerEncounteredError,MainWindow::vlcevent,this); // Release the media libvlc_media_release(vlcMedia); libvlc_media_add_option(vlcMedia, "input-repeat=-1"); // And start playback libvlc_media_player_play(vlcPlayer); } else { qDebug() << "problem with vlc media player"; const char * string=libvlc_errmsg(); if(string!=NULL) qDebug() << string; } } else { qDebug() << "problem with vlc media" << musicPath; const char * string=libvlc_errmsg(); if(string!=NULL) qDebug() << string; } } } else { qDebug() << "no vlc instance"; const char * string=libvlc_errmsg(); if(string!=NULL) qDebug() << string; } connect(CatchChallenger::BaseWindow::baseWindow,&CatchChallenger::BaseWindow::gameIsLoaded,this,&MainWindow::gameIsLoaded); }
void Media::setImageTime(QString time){ libvlc_media_add_option(_vlcMedia,(QString(":image-duration=") + time).toLocal8Bit().data()); }
/** * Thumbnailer main function. * return null if the thumbail generation failed. **/ jbyteArray Java_org_videolan_libvlc_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!"); 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(libvlc); libvlc_media_player_set_video_title_display(mp, libvlc_position_disable, 0); 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_t **tracks; libvlc_media_parse(m); int nbTracks = libvlc_media_tracks_get(m, &tracks); libvlc_media_release(m); /* 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; }
void AudioOutput::setCurrentSource( MediaStream* stream ) { tDebug() << Q_FUNC_INFO; setState( Loading ); if ( m_vlcMedia != nullptr ) { // Ensure playback is stopped, then release media libvlc_media_player_stop( m_vlcPlayer ); libvlc_media_release( m_vlcMedia ); m_vlcMedia = nullptr; } if ( m_autoDelete && m_currentStream != nullptr ) { delete m_currentStream; } m_currentStream = stream; m_totalTime = 0; m_currentTime = 0; m_justSeeked = false; m_seekable = true; QByteArray url; switch ( stream->type() ) { case MediaStream::Unknown: tDebug() << Q_FUNC_INFO << "MediaStream Type is Invalid:" << stream->type(); break; case MediaStream::Empty: tDebug() << Q_FUNC_INFO << "MediaStream is empty."; break; case MediaStream::Url: tDebug() << Q_FUNC_INFO << "MediaStream::Url:" << stream->url(); if ( stream->url().scheme().isEmpty() ) { url = "file:///"; if ( stream->url().isRelative() ) { url.append( QFile::encodeName( QDir::currentPath() ) + '/' ); } } url += stream->url().toEncoded(); break; case MediaStream::Stream: case MediaStream::IODevice: url = QByteArray( "imem://" ); break; } tDebug() << Q_FUNC_INFO << "MediaStream::Final Url:" << url; m_vlcMedia = libvlc_media_new_location( m_vlcInstance, url.constData() ); libvlc_event_manager_t* manager = libvlc_media_event_manager( m_vlcMedia ); libvlc_event_type_t events[] = { libvlc_MediaDurationChanged, }; const int eventCount = sizeof(events) / sizeof( *events ); for ( int i = 0; i < eventCount; i++ ) { libvlc_event_attach( manager, events[ i ], &AudioOutput::vlcEventCallback, this ); } libvlc_media_player_set_media( m_vlcPlayer, m_vlcMedia ); if ( stream->type() == MediaStream::Url ) { m_totalTime = libvlc_media_get_duration( m_vlcMedia ); } else if ( stream->type() == MediaStream::Stream || stream->type() == MediaStream::IODevice ) { libvlc_media_add_option_flag(m_vlcMedia, "imem-cat=4", libvlc_media_option_trusted); const char* imemData = QString( "imem-data=%1" ).arg( (uintptr_t)stream ).toLatin1().constData(); libvlc_media_add_option_flag(m_vlcMedia, imemData, libvlc_media_option_trusted); const char* imemGet = QString( "imem-get=%1" ).arg( (uintptr_t)&readCallback ).toLatin1().constData(); libvlc_media_add_option_flag(m_vlcMedia, imemGet, libvlc_media_option_trusted); const char* imemRelease = QString( "imem-release=%1" ).arg( (uintptr_t)&readDoneCallback ).toLatin1().constData(); libvlc_media_add_option_flag(m_vlcMedia, imemRelease, libvlc_media_option_trusted); const char* imemSeek = QString( "imem-seek=%1" ).arg( (uintptr_t)&MediaStream::seekCallback ).toLatin1().constData(); libvlc_media_add_option_flag(m_vlcMedia, imemSeek, libvlc_media_option_trusted); } if ( qApp->arguments().contains( "--chromecast-ip" ) ) { // This is very basic chromecast support through VLC 3+. // Totally unstable, unusable and will suck more CPU than you can think of. // If you want to improve this, please talk to the guys in #videolan and // support them. // // Knonw problems: // 1. It does not work eventhough the IP is correct. // -> Open vlc with the same commandline and accept the Certificate in the VLC UI. if ( qApp->arguments().length() > qApp->arguments().indexOf( "--chromecast-ip" ) + 1 ) { QString castIP = qApp->arguments().at( qApp->arguments().indexOf( "--chromecast-ip" ) + 1 ); QString sout( ":sout=#transcode{vcodec=none,acodec=vorb,ab=320,channels=2,samplerate=44100}:chromecast{ip=%1,mux=webm}" ); libvlc_media_add_option( m_vlcMedia, sout.arg( castIP ).toLatin1().constData() ); } else { tLog() << Q_FUNC_INFO << "Chromecast option but no IP supplied."; } } // setState( Stopped ); }
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"); }
int VLCWrapperImpl::AddOption(char* pszOption) { libvlc_media_add_option(m_pMedia, (const char*)pszOption, &m_VLCex); ProcessVLCException(&m_VLCex, m_EH); return 0; }
/** * 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; }
int transcode_stream::transcode_process(platform::process &process) { std::vector<std::string> vlc_options; vlc_options.push_back("--no-sub-autodetect-file"); if (compare_version(instance::version(), "2.1") >= 0) vlc_options.push_back("--avcodec-fast"); int font_size = -1; process >> font_size; if (font_size > 0) { vlc_options.push_back("--freetype-fontsize"); vlc_options.push_back(std::to_string(font_size)); } vlc::instance instance(vlc_options); std::string mrl, transcode, mux; process >> mrl >> transcode >> mux; std::ostringstream sout; sout << ":sout=" << from_percent(transcode) << ":std{access=fd,mux=" << mux << ",dst=" << process.output_fd() << "}"; auto media = media::from_mrl(instance, mrl); libvlc_media_add_option(media, sout.str().c_str()); std::string subtitle_file; process >> subtitle_file; if (subtitle_file != "(none)") { std::string file = from_percent(subtitle_file); #ifdef WIN32 file = from_utf16(platform::to_windows_path(file)); #endif libvlc_media_add_option(media, (":sub-file=" + file).c_str()); } size_t num_options = 0; process >> num_options; for (size_t i = 0; i < num_options; i++) { std::string option; process >> option; libvlc_media_add_option(media, from_percent(option).c_str()); } struct T { static void callback(const libvlc_event_t *e, void *opaque) { T * const t = reinterpret_cast<T *>(opaque); std::lock_guard<std::mutex> _(t->mutex); if (e->type == libvlc_MediaPlayerTimeChanged) { if (t->info) t->info->time = e->u.media_player_time_changed.new_time; } else if (e->type == libvlc_MediaPlayerPlaying) { t->started = true; if (t->track_ids.video >= -1) { libvlc_video_set_track(t->player, -1); if (t->track_ids.video > 0) libvlc_video_set_track(t->player, t->track_ids.video); } if (t->track_ids.audio >= -1) { libvlc_audio_set_track(t->player, -1); if (t->track_ids.audio >= 0) libvlc_audio_set_track(t->player, t->track_ids.audio); } if (t->track_ids.text >= -1) { libvlc_video_set_spu(t->player, -1); if (t->track_ids.text >= 0) libvlc_video_set_spu(t->player, t->track_ids.text); } } else if (e->type == libvlc_MediaPlayerEndReached) { t->end_reached = true; if (t->info) t->info->end_reached = true; } else if (e->type == libvlc_MediaPlayerEncounteredError) t->encountered_error = true; t->condition.notify_one(); } volatile shared_info *info; struct track_ids track_ids; std::mutex mutex; std::condition_variable condition; bool started; bool end_reached; bool encountered_error; libvlc_media_player_t *player; } t; unsigned info_offset(-1); process >> info_offset; process >> t.track_ids.audio >> t.track_ids.video >> t.track_ids.text; int chapter = -1; int64_t position = -1; float rate = 0.0f; process >> chapter >> position >> rate; t.info = &process.get_shared<shared_info>(info_offset); t.started = false; t.end_reached = false; t.encountered_error = false; t.player = libvlc_media_player_new_from_media(media); if (t.player) { auto event_manager = libvlc_media_player_event_manager(t.player); libvlc_event_attach(event_manager, libvlc_MediaPlayerTimeChanged, &T::callback, &t); libvlc_event_attach(event_manager, libvlc_MediaPlayerPlaying, &T::callback, &t); libvlc_event_attach(event_manager, libvlc_MediaPlayerEndReached, &T::callback, &t); libvlc_event_attach(event_manager, libvlc_MediaPlayerEncounteredError, &T::callback, &t); if (libvlc_media_player_play(t.player) == 0) { std::unique_lock<std::mutex> l(t.mutex); while (!t.end_reached && !t.encountered_error && process) { if (t.started) { l.unlock(); if (chapter >= 0) libvlc_media_player_set_chapter(t.player, chapter); if (position > 0) libvlc_media_player_set_time(t.player, position); if (std::abs(rate - 1.0f) > 0.01f) libvlc_media_player_set_rate(t.player, rate); l.lock(); t.started = false; } t.condition.wait(l); } l.unlock(); libvlc_media_player_stop(t.player); } libvlc_event_detach(event_manager, libvlc_MediaPlayerEncounteredError, &T::callback, &t); libvlc_event_detach(event_manager, libvlc_MediaPlayerEndReached, &T::callback, &t); libvlc_event_detach(event_manager, libvlc_MediaPlayerPlaying, &T::callback, &t); libvlc_event_detach(event_manager, libvlc_MediaPlayerTimeChanged, &T::callback, &t); libvlc_media_player_release(t.player); } return 0; }