Use var_Inherit* instead of var_CreateGet*.

[vlc] / src / control / media.c

diff --git a/src/control/media.c b/src/control/media.c
index 871296125e04fad3b49c50a19eba57b2a962b3c1..3f39841bd785178383c386cbd6a5f11e6156e822 100644 (file)
--- a/src/control/media.c
+++ b/src/control/media.c
@@ -158,19 +158,26 @@ static void input_item_duration_changed( const vlc_event_t *p_event,
 /**************************************************************************
  * input_item_preparsed_changed (Private) (vlc event Callback)
  **************************************************************************/
-static void input_item_preparsed_changed( const vlc_event_t *p_event,
-                                          void * user_data )
+static void input_item_preparsed_changed(const vlc_event_t *p_event,
+                                         void * user_data)
 {
-    libvlc_media_t * p_md = user_data;
+    libvlc_media_t *media = user_data;
     libvlc_event_t event;
 
+    /* Eventually notify libvlc_media_parse() */
+    vlc_mutex_lock(&media->parsed_lock);
+    media->is_parsed = true;
+    vlc_cond_broadcast(&media->parsed_cond);
+    vlc_mutex_unlock(&media->parsed_lock);
+
+
     /* Construct the event */
-    event.type = libvlc_MediaPreparsedChanged;
-    event.u.media_preparsed_changed.new_status =
+    event.type = libvlc_MediaParsedChanged;
+    event.u.media_parsed_changed.new_status =
         p_event->u.input_item_preparsed_changed.new_status;
 
     /* Send the event */
-    libvlc_event_send( p_md->p_event_manager, &event );
+    libvlc_event_send(media->p_event_manager, &event);
 }
 
 /**************************************************************************
@@ -225,12 +232,12 @@ static void uninstall_input_item_observer( libvlc_media_t *p_md )
 static void preparse_if_needed( libvlc_media_t *p_md )
 {
     /* XXX: need some locking here */
-    if (!p_md->b_preparsed)
+    if (!p_md->has_asked_preparse)
     {
         playlist_PreparseEnqueue(
                 libvlc_priv (p_md->p_libvlc_instance->p_libvlc_int)->p_playlist,
                 p_md->p_input_item );
-        p_md->b_preparsed = true;
+        p_md->has_asked_preparse = true;
     }
 }
 
@@ -262,6 +269,9 @@ libvlc_media_t * libvlc_media_new_from_input_item(
     p_md->p_input_item      = p_input_item;
     p_md->i_refcount        = 1;
 
+    vlc_cond_init(&p_md->parsed_cond);
+    vlc_mutex_init(&p_md->parsed_lock);
+
     p_md->state = libvlc_NothingSpecial;
 
     /* A media descriptor can be a playlist. When you open a playlist
@@ -274,18 +284,14 @@ libvlc_media_t * libvlc_media_new_from_input_item(
         free(p_md);
         return NULL;
     }
-    libvlc_event_manager_register_event_type( p_md->p_event_manager,
-        libvlc_MediaMetaChanged );
-    libvlc_event_manager_register_event_type( p_md->p_event_manager,
-        libvlc_MediaSubItemAdded );
-    libvlc_event_manager_register_event_type( p_md->p_event_manager,
-        libvlc_MediaFreed );
-    libvlc_event_manager_register_event_type( p_md->p_event_manager,
-        libvlc_MediaDurationChanged );
-    libvlc_event_manager_register_event_type( p_md->p_event_manager,
-        libvlc_MediaStateChanged );
-    libvlc_event_manager_register_event_type( p_md->p_event_manager,
-        libvlc_MediaPreparsedChanged );
+
+    libvlc_event_manager_t *em = p_md->p_event_manager;
+    libvlc_event_manager_register_event_type(em, libvlc_MediaMetaChanged);
+    libvlc_event_manager_register_event_type(em, libvlc_MediaSubItemAdded);
+    libvlc_event_manager_register_event_type(em, libvlc_MediaFreed);
+    libvlc_event_manager_register_event_type(em, libvlc_MediaDurationChanged);
+    libvlc_event_manager_register_event_type(em, libvlc_MediaStateChanged);
+    libvlc_event_manager_register_event_type(em, libvlc_MediaParsedChanged);
 
     vlc_gc_incref( p_md->p_input_item );
 
@@ -322,7 +328,7 @@ libvlc_media_t *libvlc_media_new_location( libvlc_instance_t *p_instance,
 libvlc_media_t *libvlc_media_new_path( libvlc_instance_t *p_instance,
                                        const char *path )
 {
-    char *mrl = make_URI( path );
+    char *mrl = make_URI( path, "file" );
     if( unlikely(mrl == NULL) )
     {
         libvlc_printerr( "Not enough memory" );
@@ -402,6 +408,9 @@ void libvlc_media_release( libvlc_media_t *p_md )
     uninstall_input_item_observer( p_md );
     vlc_gc_decref( p_md->p_input_item );
 
+    vlc_cond_destroy( &p_md->parsed_cond );
+    vlc_mutex_destroy( &p_md->parsed_lock );
+
     /* Construct the event */
     libvlc_event_t event;
     event.type = libvlc_MediaFreed;
@@ -608,10 +617,33 @@ libvlc_media_get_duration( libvlc_media_t * p_md )
 }
 
 /**************************************************************************
- * Get preparsed status for media object.
+ * Parse the media.
+ **************************************************************************/
+void
+libvlc_media_parse(libvlc_media_t *media)
+{
+    preparse_if_needed(media);
+
+    vlc_mutex_lock(&media->parsed_lock);
+    while (!media->is_parsed)
+        vlc_cond_wait(&media->parsed_cond, &media->parsed_lock);
+    vlc_mutex_unlock(&media->parsed_lock);
+}
+
+/**************************************************************************
+ * Parse the media.
+ **************************************************************************/
+void
+libvlc_media_parse_async(libvlc_media_t *media)
+{
+    preparse_if_needed(media);
+}
+
+/**************************************************************************
+ * Get parsed status for media object.
  **************************************************************************/
 int
-libvlc_media_is_preparsed( libvlc_media_t * p_md )
+libvlc_media_is_parsed( libvlc_media_t * p_md )
 {
     assert( p_md );
 
@@ -649,7 +681,7 @@ libvlc_media_get_user_data( libvlc_media_t * p_md )
  * Get media descriptor's elementary streams description
  **************************************************************************/
 int
-libvlc_media_get_es( libvlc_media_t *p_md, libvlc_media_es_t ** pp_es )
+libvlc_media_get_tracks_info( libvlc_media_t *p_md, libvlc_media_track_info_t ** pp_es )
 {
     assert( p_md );
 
@@ -657,7 +689,7 @@ libvlc_media_get_es( libvlc_media_t *p_md, libvlc_media_es_t ** pp_es )
     vlc_mutex_lock( &p_input_item->lock );
 
     const int i_es = p_input_item->i_es;
-    *pp_es = (i_es > 0) ? malloc( i_es * sizeof(libvlc_media_es_t) ) : NULL;
+    *pp_es = (i_es > 0) ? malloc( i_es * sizeof(libvlc_media_track_info_t) ) : NULL;
 
     if( !pp_es ) /* no ES, or OOM */
     {
@@ -668,13 +700,9 @@ libvlc_media_get_es( libvlc_media_t *p_md, libvlc_media_es_t ** pp_es )
     /* Fill array */
     for( int i = 0; i < i_es; i++ )
     {
-        libvlc_media_es_t *p_mes = *pp_es+i;
+        libvlc_media_track_info_t *p_mes = *pp_es+i;
         const es_format_t *p_es = p_input_item->es[i];
 
-        p_mes->i_channels = p_mes->i_rate = 0;
-        p_mes->i_width = p_mes->i_height = 0;
-
-
         p_mes->i_codec = p_es->i_codec;
         p_mes->i_id = p_es->i_id;
 
@@ -685,20 +713,20 @@ libvlc_media_get_es( libvlc_media_t *p_md, libvlc_media_es_t ** pp_es )
         {
         case UNKNOWN_ES:
         default:
-            p_mes->i_type = libvlc_es_unknown;
+            p_mes->i_type = libvlc_track_unknown;
             break;
         case VIDEO_ES:
-            p_mes->i_type = libvlc_es_video;
-            p_mes->i_height = p_es->video.i_height;
-            p_mes->i_width = p_es->video.i_width;
+            p_mes->i_type = libvlc_track_video;
+            p_mes->u.video.i_height = p_es->video.i_height;
+            p_mes->u.video.i_width = p_es->video.i_width;
             break;
         case AUDIO_ES:
-            p_mes->i_type = libvlc_es_audio;
-            p_mes->i_channels = p_es->audio.i_channels;
-            p_mes->i_rate = p_es->audio.i_rate;
+            p_mes->i_type = libvlc_track_audio;
+            p_mes->u.audio.i_channels = p_es->audio.i_channels;
+            p_mes->u.audio.i_rate = p_es->audio.i_rate;
             break;
         case SPU_ES:
-            p_mes->i_type = libvlc_es_text;
+            p_mes->i_type = libvlc_track_text;
             break;
         }
     }