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) : "";
}
