char * mediacontrol_get_mrl( mediacontrol_Instance *self, mediacontrol_Exception *exception ) { libvlc_media_t * p_media; 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_NULL( &ex ); if ( ! p_media ) { return strdup( "" ); } else { char * psz_mrl; psz_mrl = libvlc_media_get_mrl( p_media, &ex ); HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); return psz_mrl; } }
QString NPlaybackEngineVlc::currentMedia() const { libvlc_media_t *media = libvlc_media_player_get_media(m_mediaPlayer); if (media != NULL) return QUrl(QUrl::fromPercentEncoding(libvlc_media_get_mrl(media))).toLocalFile(); return QString(); }
static int expand_media_internal(JNIEnv *env, libvlc_instance_t* p_instance, jobject arrayList, libvlc_media_t* p_md) { if(!p_md) { return -1; } libvlc_media_list_t* p_subitems = libvlc_media_subitems(p_md); libvlc_media_release(p_md); if(p_subitems) { // Expand any subitems if needed int subitem_count = libvlc_media_list_count(p_subitems); if(subitem_count > 0) { LOGD("Found %d subitems, expanding", subitem_count); jclass arrayListClass; jmethodID methodAdd; arrayListGetIDs(env, &arrayListClass, &methodAdd, NULL); for(int i = subitem_count - 1; i >= 0; i--) { libvlc_media_t* p_subitem = libvlc_media_list_item_at_index(p_subitems, i); char* p_subitem_uri = libvlc_media_get_mrl(p_subitem); arrayListStringAdd(env, arrayListClass, methodAdd, arrayList, p_subitem_uri); free(p_subitem_uri); } } libvlc_media_list_release(p_subitems); if(subitem_count > 0) { return 0; } else { return -1; } } else { return -1; } }
static void subitem_added(const libvlc_event_t *event, void *user_data) { #ifdef _WIN32 #define FILE_SEPARATOR '\\' #else #define FILE_SEPARATOR '/' #endif bool *subitems_found = user_data; libvlc_media_t *m = event->u.media_subitem_added.new_child; assert (m); char *mrl = libvlc_media_get_mrl (m); assert (mrl); const char *file = strrchr (mrl, FILE_SEPARATOR); assert (file); file++; log ("subitem_added, file: %s\n", file); for (unsigned i = 0; i < TEST_SUBITEMS_COUNT; ++i) { if (strcmp (test_media_subitems_list[i].file, file) == 0) { assert (!subitems_found[i]); assert (libvlc_media_get_type(m) == test_media_subitems_list[i].type); subitems_found[i] = true; } } free (mrl); #undef FILE_SEPARATOR }
static char * path_to_mrl(libvlc_instance_t *p_vlc, const char *psz_path) { libvlc_media_t *p_m = libvlc_media_new_path(p_vlc, psz_path); char *psz_mrl = libvlc_media_get_mrl(p_m); libvlc_media_release(p_m); return psz_mrl; }
JNIEXPORT void JNICALL NAME(nativePrepareAsync)(JNIEnv *env, jobject thiz) { libvlc_media_t *media = (libvlc_media_t *) getIntValue(env, thiz, "mLibVlcMedia"); char *mrl = libvlc_media_get_mrl(media); if (strncmp(mrl, "file://", 7) == 0) libvlc_media_parse_async(media); else { libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer"); libvlc_media_player_play(mp); } free(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 ); } }
static void test_media_has_slaves_from_parent(libvlc_instance_t *p_vlc, libvlc_media_slave_t *p_expected_slaves, unsigned i_expected_slaves) { libvlc_media_t *p_m = libvlc_media_new_path(p_vlc, SLAVES_DIR); assert(p_m != NULL); printf("Parse media dir to get subitems\n"); media_parse_sync(p_m); char *psz_main_media_mrl = path_to_mrl(p_vlc, MAIN_MEDIA_PATH); assert(psz_main_media_mrl != NULL); printf("Main media mrl: '%s'\n", psz_main_media_mrl); printf("Fetch main media from subitems\n"); libvlc_media_list_t *p_ml = libvlc_media_subitems(p_m); assert(p_ml != NULL); libvlc_media_list_lock(p_ml); int i_count = libvlc_media_list_count(p_ml); assert(i_count > 0); libvlc_media_t *p_subm = NULL; for (int i = 0; i < i_count; ++i) { p_subm = libvlc_media_list_item_at_index(p_ml, i); assert(p_subm != NULL); char *psz_mrl = libvlc_media_get_mrl(p_subm); assert(psz_mrl != NULL); if (strcmp(psz_main_media_mrl, psz_mrl) == 0) { printf("Found main media\n"); free(psz_mrl); break; } free(psz_mrl); libvlc_media_release(p_subm); p_subm = NULL; } free(psz_main_media_mrl); libvlc_media_list_unlock(p_ml); libvlc_media_list_release(p_ml); assert(p_subm != NULL); test_expected_slaves(p_subm, p_expected_slaves, i_expected_slaves); libvlc_media_release(p_subm); libvlc_media_release(p_m); }
JNIEXPORT void JNICALL NAME(nativePrepare)(JNIEnv *env, jobject thiz) { libvlc_media_t *media = (libvlc_media_t *) getIntValue(env, thiz, "mLibVlcMedia"); char *mrl = libvlc_media_get_mrl(media); if (strncmp(mrl, "file://", 7) == 0) libvlc_media_parse(media); else { vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, thiz, "mNativeMediaParseLock"); vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, thiz, "mNativeMediaParseCond"); libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer"); libvlc_media_player_play(mp); vlc_mutex_lock(parse_lock); while (!getIntValue(env, thiz, "mNativeMediaParsed")) vlc_cond_wait(parse_cond, parse_lock); vlc_mutex_unlock(parse_lock); } free(mrl); }
MediaMeta VLCWrapper::GetItemMeta (int row, const QString& location) const { MediaMeta meta; auto m = libvlc_media_list_item_at_index (List_.get (), row); if (!m) return meta; if (!QUrl (location).scheme ().isEmpty ()) { meta.Artist_ = tr ("Internet stream"); meta.Title_ = location; return meta; } libvlc_media_parse (m); meta.Artist_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Artist)); meta.Album_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Album)); meta.Title_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Title)); meta.Genre_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Genre)); meta.Date_ = libvlc_media_get_meta (m, libvlc_meta_Date); meta.Length_ = libvlc_media_get_duration (m) / 1000; if (location.isNull ()) meta.Location_ = QUrl (libvlc_media_get_mrl (m)); else meta.Location_ = QUrl (location); libvlc_media_track_info_t *pTrackInfo; int numOfStream = libvlc_media_get_tracks_info (m, &pTrackInfo); if (numOfStream >= 1) meta.Type_ = pTrackInfo->i_type; meta.TrackNumber_ = QString (libvlc_media_get_meta (m, libvlc_meta_TrackNumber)) .toInt (); return meta; }
static void vlc_event_callback(const libvlc_event_t *ev, void *data) { JNIEnv *env; bool isAttached = false; if (eventHandlerInstance == NULL) return; if ((*myVm)->GetEnv(myVm, (void**) &env, JNI_VERSION_1_2) < 0) { if ((*myVm)->AttachCurrentThread(myVm, &env, NULL) < 0) return; isAttached = true; } /* Creating the bundle in C allows us to subscribe to more events * and get better flexibility for each event. For example, we can * have totally different types of data for each event, instead of, * for example, only an integer and/or string. */ jclass clsBundle = (*env)->FindClass(env, "android/os/Bundle"); jmethodID clsCtor = (*env)->GetMethodID(env, clsBundle, "<init>", "()V" ); jobject bundle = (*env)->NewObject(env, clsBundle, clsCtor); jmethodID putInt = (*env)->GetMethodID(env, clsBundle, "putInt", "(Ljava/lang/String;I)V" ); jmethodID putFloat = (*env)->GetMethodID(env, clsBundle, "putFloat", "(Ljava/lang/String;F)V" ); jmethodID putString = (*env)->GetMethodID(env, clsBundle, "putString", "(Ljava/lang/String;Ljava/lang/String;)V" ); if (ev->type == libvlc_MediaPlayerPositionChanged) { jstring sData = (*env)->NewStringUTF(env, "data"); (*env)->CallVoidMethod(env, bundle, putFloat, sData, ev->u.media_player_position_changed.new_position); (*env)->DeleteLocalRef(env, sData); } else if(ev->type == libvlc_MediaPlayerVout) { /* For determining the vout/ES track change */ jstring sData = (*env)->NewStringUTF(env, "data"); (*env)->CallVoidMethod(env, bundle, putInt, sData, ev->u.media_player_vout.new_count); (*env)->DeleteLocalRef(env, sData); } else if(ev->type == libvlc_MediaListItemAdded || ev->type == libvlc_MediaListItemDeleted ) { jstring item_uri = (*env)->NewStringUTF(env, "item_uri"); jstring item_index = (*env)->NewStringUTF(env, "item_index"); char* mrl = libvlc_media_get_mrl( ev->type == libvlc_MediaListItemAdded ? ev->u.media_list_item_added.item : ev->u.media_list_item_deleted.item ); jstring item_uri_value = (*env)->NewStringUTF(env, mrl); jint item_index_value; if(ev->type == libvlc_MediaListItemAdded) item_index_value = ev->u.media_list_item_added.index; else item_index_value = ev->u.media_list_item_deleted.index; (*env)->CallVoidMethod(env, bundle, putString, item_uri, item_uri_value); (*env)->CallVoidMethod(env, bundle, putInt, item_index, item_index_value); (*env)->DeleteLocalRef(env, item_uri); (*env)->DeleteLocalRef(env, item_uri_value); (*env)->DeleteLocalRef(env, item_index); free(mrl); } /* Get the object class */ jclass cls = (*env)->GetObjectClass(env, eventHandlerInstance); if (!cls) { LOGE("EventHandler: failed to get class reference"); goto end; } /* Find the callback ID */ jmethodID methodID = (*env)->GetMethodID(env, cls, "callback", "(ILandroid/os/Bundle;)V"); if (methodID) { (*env)->CallVoidMethod(env, eventHandlerInstance, methodID, ev->type, bundle); } else { LOGE("EventHandler: failed to get the callback method"); } end: (*env)->DeleteLocalRef(env, bundle); if (isAttached) (*myVm)->DetachCurrentThread(myVm); }
mediacontrol_StreamInformation * mediacontrol_get_stream_information( mediacontrol_Instance *self, mediacontrol_PositionKey a_key, mediacontrol_Exception *exception ) { (void)a_key; mediacontrol_StreamInformation *retval = NULL; libvlc_media_t * p_media; libvlc_exception_t ex; libvlc_exception_init( &ex ); retval = ( mediacontrol_StreamInformation* ) malloc( sizeof( mediacontrol_StreamInformation ) ); if( ! retval ) { RAISE( mediacontrol_InternalException, "Out of memory" ); return NULL; } p_media = libvlc_media_player_get_media( self->p_media_player, &ex ); HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); if( ! p_media ) { /* No p_media defined */ retval->streamstatus = mediacontrol_UndefinedStatus; retval->url = strdup( "" ); retval->position = 0; retval->length = 0; } else { libvlc_state_t state; state = libvlc_media_player_get_state( self->p_media_player, &ex ); HANDLE_LIBVLC_EXCEPTION_NULL( &ex ); switch( state ) { case libvlc_NothingSpecial: retval->streamstatus = mediacontrol_UndefinedStatus; break; case libvlc_Opening : retval->streamstatus = mediacontrol_InitStatus; break; case libvlc_Buffering: retval->streamstatus = mediacontrol_BufferingStatus; break; case libvlc_Playing: retval->streamstatus = mediacontrol_PlayingStatus; break; case libvlc_Paused: retval->streamstatus = mediacontrol_PauseStatus; break; case libvlc_Stopped: retval->streamstatus = mediacontrol_StopStatus; break; case libvlc_Forward: retval->streamstatus = mediacontrol_ForwardStatus; break; case libvlc_Backward: retval->streamstatus = mediacontrol_BackwardStatus; break; case libvlc_Ended: retval->streamstatus = mediacontrol_EndStatus; break; case libvlc_Error: retval->streamstatus = mediacontrol_ErrorStatus; break; default : retval->streamstatus = mediacontrol_UndefinedStatus; break; } retval->url = libvlc_media_get_mrl( p_media, &ex ); retval->position = libvlc_media_player_get_time( self->p_media_player, &ex ); if( libvlc_exception_raised( &ex ) ) { libvlc_exception_clear( &ex ); retval->position = 0; } retval->length = libvlc_media_player_get_length( self->p_media_player, &ex ); if( libvlc_exception_raised( &ex ) ) { libvlc_exception_clear( &ex ); retval->length = 0; } } return retval; }
static void vlc_event_callback(const libvlc_event_t *ev, void *data) { JNIEnv *env; jobject obj_VlcMediaPlayer = g_obj_VlcMediaPlayer; jobject obj_VlcEvent; int trigger = 1; if ((*gJVM)->AttachCurrentThread(gJVM, &env, 0) < 0) return; obj_VlcEvent = (*env)->AllocObject(env, clz_VlcEvent); if (!obj_VlcEvent) return; libvlc_media_t *media = (libvlc_media_t *) getIntValue(env, obj_VlcMediaPlayer, "mLibVlcMedia"); char *mrl = libvlc_media_get_mrl(media); libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, obj_VlcMediaPlayer, "mLibVlcMediaPlayer"); vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParseLock"); vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParseCond"); (*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_eventType, ev->type); switch (ev->type) { case libvlc_MediaDurationChanged: { int64_t duration = ev->u.media_duration_changed.new_duration; (*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) duration); break; } case libvlc_MediaStateChanged: { int state = ev->u.media_state_changed.new_state; (*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_intValue, state); /* wake up if there is an error */ if (state == libvlc_MediaPlayerEncounteredError) { vlc_mutex_lock(parse_lock); setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParsed", 2); vlc_cond_broadcast(parse_cond); vlc_mutex_unlock(parse_lock); } break; } case libvlc_MediaParsedChanged: { libvlc_media_player_play(mp); trigger = 0; break; } case libvlc_MediaPlayerBuffering: { float cache = ev->u.media_player_buffering.new_cache; (*env)->SetFloatField(env, obj_VlcEvent, f_VlcEvent_floatValue, cache); int count = getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaBufferingCount"); if ((int) cache == 100) { setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaBufferingCount", count + 1); /* if it's the first time */ if (count == 0) { /* send buffering update event now */ (*env)->CallVoidMethod(env, obj_VlcMediaPlayer, m_VlcMediaPlayer_onVlcEvent, obj_VlcEvent); libvlc_media_player_set_pause(mp, 1); /* asynchonous preparing is done */ vlc_mutex_lock(parse_lock); setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParsed", 1); vlc_cond_broadcast(parse_cond); vlc_mutex_unlock(parse_lock); /* simulate a media prepared event */ (*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_eventType, libvlc_MediaParsedChanged); (*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, 1); } } break; } case libvlc_MediaPlayerTimeChanged: { int64_t time = ev->u.media_player_time_changed.new_time; (*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) time); break; } case libvlc_MediaPlayerPositionChanged: { float position = ev->u.media_player_position_changed.new_position; (*env)->SetFloatField(env, obj_VlcEvent, f_VlcEvent_floatValue, position); break; } case libvlc_MediaPlayerSeekableChanged: { int seekable = ev->u.media_player_seekable_changed.new_seekable; (*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, seekable > 0); break; } case libvlc_MediaPlayerPausableChanged: { int pausable = ev->u.media_player_pausable_changed.new_pausable; (*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, pausable > 0); break; } case libvlc_MediaPlayerTitleChanged: { int title = ev->u.media_player_title_changed.new_title; (*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_intValue, title); break; } case libvlc_MediaPlayerSnapshotTaken: { char *p = ev->u.media_player_snapshot_taken.psz_filename; jstring path = (*env)->NewStringUTF(env, p); (*env)->SetObjectField(env, obj_VlcEvent, f_VlcEvent_stringValue, path); break; } case libvlc_MediaPlayerLengthChanged: { int64_t length = ev->u.media_player_length_changed.new_length; (*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) length); break; } default: break; } if (trigger) (*env)->CallVoidMethod(env, obj_VlcMediaPlayer, m_VlcMediaPlayer_onVlcEvent, obj_VlcEvent); (*env)->DeleteLocalRef(env, obj_VlcEvent); free(mrl); /* EXPLAIN: this is called in pthread wrapper routines */ // (*gJVM)->DetachCurrentThread(gJVM); }
std::string media::mrl() const noexcept { return libvlc_media ? libvlc_media_get_mrl(libvlc_media) : ""; }