]> git.sesse.net Git - vlc/blobdiff - src/input/item.c
Add a function to get the Title and fallback to the name if the title is empty.
[vlc] / src / input / item.c
index 91d30deff38e59457bfe355602eb47c7db5b8081..864e84ae577bb555aa96e7836f21b746983494cf 100644 (file)
@@ -30,7 +30,7 @@
 #include "vlc_playlist.h"
 #include "vlc_interface.h"
 
-#include "input_internal.h"
+#include "item.h"
 
 static void GuessType( input_item_t *p_item );
 
@@ -39,6 +39,7 @@ static void GuessType( input_item_t *p_item );
 static inline void input_item_Init( vlc_object_t *p_o, input_item_t *p_i )
 {
     memset( p_i, 0, sizeof(input_item_t) );
+
     p_i->psz_name = NULL;
     p_i->psz_uri = NULL;
     TAB_INIT( p_i->i_es, p_i->es );
@@ -115,20 +116,83 @@ static inline void input_item_Clean( input_item_t *p_i )
 
     vlc_mutex_destroy( &p_i->lock );
 }
+void input_item_SetErrorWhenReading( input_item_t *p_i, bool b_error )
+{
+    bool b_changed;
+
+    vlc_mutex_lock( &p_i->lock );
+
+    b_changed = p_i->b_error_when_reading != b_error;
+    p_i->b_error_when_reading = b_error;
+
+    vlc_mutex_unlock( &p_i->lock );
+
+    if( b_changed )
+    {
+        vlc_event_t event;
 
-void input_item_SetHasErrorWhenReading( input_item_t *p_i, bool error )
+        event.type = vlc_InputItemErrorWhenReadingChanged;
+        event.u.input_item_error_when_reading_changed.new_value = b_error;
+        vlc_event_send( &p_i->event_manager, &event );
+    }
+}
+void input_item_SetPreparsed( input_item_t *p_i, bool b_preparsed )
 {
-    vlc_event_t event;
+    bool b_send_event = false;
 
-    if( p_i->b_error_when_reading == error )
-        return;
+    vlc_mutex_lock( &p_i->lock );
 
-    p_i->b_error_when_reading = error;
+    if( !p_i->p_meta )
+        p_i->p_meta = vlc_meta_New();
 
-    /* Notify interested third parties */
-    event.type = vlc_InputItemErrorWhenReadingChanged;
-    event.u.input_item_error_when_reading_changed.new_value = error;
-    vlc_event_send( &p_i->event_manager, &event );
+    int i_new_status;
+    if( b_preparsed )
+        i_new_status = p_i->p_meta->i_status | ITEM_PREPARSED;
+    else
+        i_new_status = p_i->p_meta->i_status & ~ITEM_PREPARSED;
+    if( p_i->p_meta->i_status != i_new_status )
+    {
+        p_i->p_meta->i_status = i_new_status;
+        b_send_event = true;
+    }
+
+    vlc_mutex_unlock( &p_i->lock );
+
+    if( b_send_event )
+    {
+        vlc_event_t event;
+        event.type = vlc_InputItemPreparsedChanged;
+        event.u.input_item_preparsed_changed.new_status = i_new_status;
+        vlc_event_send( &p_i->event_manager, &event );
+    }
+}
+void input_item_SetArtNotFound( input_item_t *p_i, bool b_not_found )
+{
+    vlc_mutex_lock( &p_i->lock );
+
+    if( !p_i->p_meta )
+        p_i->p_meta = vlc_meta_New();
+
+    if( b_not_found )
+        p_i->p_meta->i_status |= ITEM_ART_NOTFOUND;
+    else
+        p_i->p_meta->i_status &= ~ITEM_ART_NOTFOUND;
+
+    vlc_mutex_unlock( &p_i->lock );
+}
+void input_item_SetArtFetched( input_item_t *p_i, bool b_art_fetched )
+{
+    vlc_mutex_lock( &p_i->lock );
+
+    if( !p_i->p_meta )
+        p_i->p_meta = vlc_meta_New();
+
+    if( b_art_fetched )
+        p_i->p_meta->i_status |= ITEM_ART_FETCHED;
+    else
+        p_i->p_meta->i_status &= ~ITEM_ART_FETCHED;
+
+    vlc_mutex_unlock( &p_i->lock );
 }
 
 void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val )
@@ -147,90 +211,77 @@ void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const cha
     vlc_event_send( &p_i->event_manager, &event );
 }
 
-/**
- * Get the item from an input thread
- */
-input_item_t *input_GetItem( input_thread_t *p_input )
-{
-    assert( p_input && p_input->p );
-    return p_input->p->input.p_item;
-}
-
+/* FIXME GRRRRRRRRRR args should be in the reverse order to be 
+ * consistant with (nearly?) all or copy funcs */
 void input_item_CopyOptions( input_item_t *p_parent,
-                                          input_item_t *p_child )
+                             input_item_t *p_child )
 {
-    int i;
-    for( i = 0 ; i< p_parent->i_options; i++ )
+    vlc_mutex_lock( &p_parent->lock );
+
+    for( int i = 0 ; i< p_parent->i_options; i++ )
     {
-        char *psz_option= strdup( p_parent->ppsz_options[i] );
-        if( !strcmp( psz_option, "meta-file" ) )
-        {
-            free( psz_option );
+        if( !strcmp( p_parent->ppsz_options[i], "meta-file" ) )
             continue;
-        }
-        p_child->i_options++;
-        p_child->ppsz_options = (char **)realloc( p_child->ppsz_options,
-                                                  p_child->i_options *
-                                                  sizeof( char * ) );
-        p_child->ppsz_options[p_child->i_options-1] = psz_option;
-        p_child->optflagc++;
-        p_child->optflagv = (uint8_t *)realloc( p_child->optflagv,
-                                                p_child->optflagc );
-        p_child->optflagv[p_child->optflagc - 1] = p_parent->optflagv[i];
+
+        input_item_AddOption( p_child,
+                              p_parent->ppsz_options[i],
+                              p_parent->optflagv[i] );
     }
-}
 
-void input_item_SetName( input_item_t *p_item, const char *psz_name )
-{
-    free( p_item->psz_name );
-    p_item->psz_name = strdup( psz_name );
+    vlc_mutex_unlock( &p_parent->lock );
 }
 
 /* This won't hold the item, but can tell to interested third parties
  * Like the playlist, that there is a new sub item. With this design
  * It is not the input item's responsability to keep all the ref of
  * the input item children. */
-void input_item_AddSubItem( input_item_t *p_parent,
-                                         input_item_t *p_child )
+void input_item_AddSubItem( input_item_t *p_parent, input_item_t *p_child )
 {
-    vlc_event_t event;
+    vlc_mutex_lock( &p_parent->lock );
 
     p_parent->i_type = ITEM_TYPE_PLAYLIST;
 
+    vlc_mutex_unlock( &p_parent->lock );
+
     /* Notify interested third parties */
+    vlc_event_t event;
+
     event.type = vlc_InputItemSubItemAdded;
     event.u.input_item_subitem_added.p_new_child = p_child;
     vlc_event_send( &p_parent->event_manager, &event );
 }
 
-int input_item_AddOption (input_item_t *item, const char *str)
+bool input_item_HasErrorWhenReading( input_item_t *p_item )
 {
-    return input_item_AddOpt (item, str, VLC_INPUT_OPTION_TRUSTED);
-}
+    vlc_mutex_lock( &p_item->lock );
 
-bool input_item_HasErrorWhenReading (input_item_t *item)
-{
-    return item->b_error_when_reading;
+    bool b_error = p_item->b_error_when_reading;
+
+    vlc_mutex_unlock( &p_item->lock );
+
+    return b_error;
 }
 
-bool input_item_MetaMatch( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz )
+bool input_item_MetaMatch( input_item_t *p_i,
+                           vlc_meta_type_t meta_type, const char *psz )
 {
     vlc_mutex_lock( &p_i->lock );
+
     if( !p_i->p_meta )
     {
         vlc_mutex_unlock( &p_i->lock );
         return false;
     }
-    const char * meta = vlc_meta_Get( p_i->p_meta, meta_type );
-    bool ret = meta && strcasestr( meta, psz );
+    const char *psz_meta = vlc_meta_Get( p_i->p_meta, meta_type );
+    bool b_ret = psz_meta && strcasestr( psz_meta, psz );
+
     vlc_mutex_unlock( &p_i->lock );
 
-    return ret;
+    return b_ret;
 }
 
-char * input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
+char *input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
 {
-    char * psz = NULL;
     vlc_mutex_lock( &p_i->lock );
 
     if( !p_i->p_meta )
@@ -239,6 +290,7 @@ char * input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
         return NULL;
     }
 
+    char *psz = NULL;
     if( vlc_meta_Get( p_i->p_meta, meta_type ) )
         psz = strdup( vlc_meta_Get( p_i->p_meta, meta_type ) );
 
@@ -246,86 +298,169 @@ char * input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
     return psz;
 }
 
-char * input_item_GetName( input_item_t * p_i )
+/* Get the title of a given item or fallback to the name if the title is empty */
+char *input_item_GetTitleFbName( input_item_t *p_item )
 {
-    vlc_mutex_lock( &p_i->lock );
-    char *psz_s = p_i->psz_name ? strdup( p_i->psz_name ) : NULL;
-    vlc_mutex_unlock( &p_i->lock );
-    return psz_s;
+    char *psz_ret;
+    vlc_mutex_lock( &p_item->lock );
+
+    if( !p_item->p_meta )
+    {
+        vlc_mutex_unlock( &p_item->lock );
+        return NULL;
+    }
+
+    const char *psz_meta = vlc_meta_Get( p_item->p_meta, vlc_meta_Title );
+    if( !EMPTY_STR( psz_meta ) )
+        psz_ret = strdup( psz_meta );
+    else
+        psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
+
+    vlc_mutex_unlock( &p_item->lock );
+    return psz_ret;
 }
 
-char * input_item_GetURI( input_item_t * p_i )
+char *input_item_GetName( input_item_t *p_item )
+{
+    vlc_mutex_lock( &p_item->lock );
+
+    char *psz_name = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
+
+    vlc_mutex_unlock( &p_item->lock );
+    return psz_name;
+}
+void input_item_SetName( input_item_t *p_item, const char *psz_name )
+{
+    vlc_mutex_lock( &p_item->lock );
+
+    free( p_item->psz_name );
+    p_item->psz_name = strdup( psz_name );
+
+    vlc_mutex_unlock( &p_item->lock );
+}
+
+char *input_item_GetURI( input_item_t *p_i )
 {
     vlc_mutex_lock( &p_i->lock );
+
     char *psz_s = p_i->psz_uri ? strdup( p_i->psz_uri ) : NULL;
+
     vlc_mutex_unlock( &p_i->lock );
     return psz_s;
 }
-
-void input_item_SetURI( input_item_t * p_i, char * psz_uri )
+void input_item_SetURI( input_item_t *p_i, const char *psz_uri )
 {
     vlc_mutex_lock( &p_i->lock );
+
     free( p_i->psz_uri );
     p_i->psz_uri = strdup( psz_uri );
+
+    GuessType( p_i );
+
+    if( !p_i->psz_name && p_i->i_type == ITEM_TYPE_FILE )
+    {
+        const char *psz_filename = strrchr( p_i->psz_uri, DIR_SEP_CHAR );
+        if( psz_filename && *psz_filename == DIR_SEP_CHAR )
+            psz_filename++;
+        if( psz_filename && *psz_filename )
+            p_i->psz_name = strdup( psz_filename );
+    }
+
+    if( !p_i->psz_name )
+        p_i->psz_name = strdup( p_i->psz_uri );
+
     vlc_mutex_unlock( &p_i->lock );
 }
 
-mtime_t input_item_GetDuration( input_item_t * p_i )
+mtime_t input_item_GetDuration( input_item_t *p_i )
 {
     vlc_mutex_lock( &p_i->lock );
+
     mtime_t i_duration = p_i->i_duration;
+
     vlc_mutex_unlock( &p_i->lock );
     return i_duration;
 }
 
-void input_item_SetDuration( input_item_t * p_i, mtime_t i_duration )
+void input_item_SetDuration( input_item_t *p_i, mtime_t i_duration )
 {
-    bool send_event = false;
+    bool b_send_event = false;
 
     vlc_mutex_lock( &p_i->lock );
     if( p_i->i_duration != i_duration )
     {
         p_i->i_duration = i_duration;
-        send_event = true;
+        b_send_event = true;
     }
     vlc_mutex_unlock( &p_i->lock );
 
-    if ( send_event == true )
+    if( b_send_event )
     {
         vlc_event_t event;
+
         event.type = vlc_InputItemDurationChanged;
         event.u.input_item_duration_changed.new_duration = i_duration;
         vlc_event_send( &p_i->event_manager, &event );
     }
-
-    return;
 }
 
 
-bool input_item_IsPreparsed( input_item_t *p_i )
+bool input_item_IsPreparsed( input_item_t *p_item )
 {
-    return p_i->p_meta ? p_i->p_meta->i_status & ITEM_PREPARSED : false ;
+    vlc_mutex_lock( &p_item->lock );
+    bool b_preparsed = p_item->p_meta ? ( p_item->p_meta->i_status & ITEM_PREPARSED ) != 0 : false;
+    vlc_mutex_unlock( &p_item->lock );
+
+    return b_preparsed;
 }
 
-bool input_item_IsArtFetched( input_item_t *p_i )
+bool input_item_IsArtFetched( input_item_t *p_item )
 {
-    return p_i->p_meta ? p_i->p_meta->i_status & ITEM_ART_FETCHED : false ;
+    vlc_mutex_lock( &p_item->lock );
+    bool b_fetched = p_item->p_meta ? ( p_item->p_meta->i_status & ITEM_ART_FETCHED ) != 0 : false;
+    vlc_mutex_unlock( &p_item->lock );
+
+    return b_fetched;
 }
 
-const vlc_meta_t * input_item_GetMetaObject( input_item_t *p_i )
+static void input_item_Destroy ( gc_object_t *p_gc )
 {
-    if( !p_i->p_meta )
-        p_i->p_meta = vlc_meta_New();
+    input_item_t *p_item = vlc_priv( p_gc, input_item_t );
 
-    return p_i->p_meta;
+    input_item_Clean( p_item );
+    free( p_item );
 }
 
-void input_item_MetaMerge( input_item_t *p_i, const vlc_meta_t * p_new_meta )
+int input_item_AddOption( input_item_t *p_input, const char *psz_option,
+                          unsigned flags )
 {
-    if( !p_i->p_meta )
-        p_i->p_meta = vlc_meta_New();
+    int err = VLC_SUCCESS;
+
+    if( psz_option == NULL )
+        return VLC_EGENERIC;
+
+    vlc_mutex_lock( &p_input->lock );
+    if (flags & VLC_INPUT_OPTION_UNIQUE)
+    {
+        for (int i = 0 ; i < p_input->i_options; i++)
+            if( !strcmp( p_input->ppsz_options[i], psz_option ) )
+                goto out;
+    }
+
+    uint8_t *flagv = realloc (p_input->optflagv, p_input->optflagc + 1);
+    if (flagv == NULL)
+    {
+        err = VLC_ENOMEM;
+        goto out;
+    }
+    p_input->optflagv = flagv;
+    flagv[p_input->optflagc++] = flags;
 
-    vlc_meta_Merge( p_i->p_meta, p_new_meta );
+    INSERT_ELEM( p_input->ppsz_options, p_input->i_options,
+                 p_input->i_options, strdup( psz_option ) );
+out:
+    vlc_mutex_unlock( &p_input->lock );
+    return err;
 }
 
 /**
@@ -339,21 +474,19 @@ void input_item_MetaMerge( input_item_t *p_i, const vlc_meta_t * p_new_meta )
  *         pointer.
  */
 char *input_item_GetInfo( input_item_t *p_i,
-                              const char *psz_cat,
-                              const char *psz_name )
+                          const char *psz_cat,
+                          const char *psz_name )
 {
-    int i,j;
-
     vlc_mutex_lock( &p_i->lock );
 
-    for( i = 0 ; i< p_i->i_categories  ; i++ )
+    for( int i = 0; i< p_i->i_categories; i++ )
     {
-        info_category_t *p_cat = p_i->pp_categories[i];
+        const info_category_t *p_cat = p_i->pp_categories[i];
 
         if( !psz_cat || strcmp( p_cat->psz_name, psz_cat ) )
             continue;
 
-        for( j = 0; j < p_cat->i_infos ; j++ )
+        for( int j = 0; j < p_cat->i_infos; j++ )
         {
             if( !strcmp( p_cat->pp_infos[j]->psz_name, psz_name ) )
             {
@@ -367,69 +500,16 @@ char *input_item_GetInfo( input_item_t *p_i,
     return strdup( "" );
 }
 
-static void input_item_Destroy ( gc_object_t *p_this )
-{
-    vlc_object_t *p_obj = (vlc_object_t *)p_this->p_destructor_arg;
-    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
-    input_item_t *p_input = (input_item_t *) p_this;
-    int i;
-
-    input_item_Clean( p_input );
-
-    vlc_object_lock( p_obj->p_libvlc );
-
-    ARRAY_BSEARCH( priv->input_items,->i_id, int, p_input->i_id, i);
-    if( i != -1 )
-        ARRAY_REMOVE( priv->input_items, i);
-
-    vlc_object_unlock( p_obj->p_libvlc );
-
-    free( p_input );
-}
-
-int input_item_AddOpt( input_item_t *p_input, const char *psz_option,
-                      unsigned flags )
-{
-    int err = VLC_SUCCESS;
-
-    if( psz_option == NULL )
-        return VLC_EGENERIC;
-
-    vlc_mutex_lock( &p_input->lock );
-    if (flags & VLC_INPUT_OPTION_UNIQUE)
-    {
-        for (int i = 0 ; i < p_input->i_options; i++)
-            if( !strcmp( p_input->ppsz_options[i], psz_option ) )
-                goto out;
-    }
-
-    uint8_t *flagv = realloc (p_input->optflagv, p_input->optflagc + 1);
-    if (flagv == NULL)
-    {
-        err = VLC_ENOMEM;
-        goto out;
-    }
-    p_input->optflagv = flagv;
-    flagv[p_input->optflagc++] = flags;
-
-    INSERT_ELEM( p_input->ppsz_options, p_input->i_options,
-                 p_input->i_options, strdup( psz_option ) );
-out:
-    vlc_mutex_unlock( &p_input->lock );
-    return err;
-}
-
-int input_item_AddInfo( input_item_t *p_i,
-                            const char *psz_cat,
-                            const char *psz_name,
-                            const char *psz_format, ... )
+static int InputItemVaAddInfo( input_item_t *p_i,
+                               const char *psz_cat,
+                               const char *psz_name,
+                               const char *psz_format, va_list args )
 {
-    va_list args;
     int i;
     info_t *p_info = NULL;
     info_category_t *p_cat = NULL ;
 
-    vlc_mutex_lock( &p_i->lock );
+    vlc_assert_locked( &p_i->lock );
 
     for( i = 0 ; i < p_i->i_categories ; i ++ )
     {
@@ -441,11 +521,9 @@ int input_item_AddInfo( input_item_t *p_i,
     }
     if( !p_cat )
     {
-        if( !(p_cat = (info_category_t *)malloc( sizeof(info_category_t) )) )
-        {
-            vlc_mutex_unlock( &p_i->lock );
+        if( !(p_cat = malloc( sizeof(*p_cat) )) )
             return VLC_ENOMEM;
-        }
+
         p_cat->psz_name = strdup( psz_cat );
         p_cat->i_infos = 0;
         p_cat->pp_infos = 0;
@@ -464,11 +542,9 @@ int input_item_AddInfo( input_item_t *p_i,
 
     if( !p_info )
     {
-        if( ( p_info = (info_t *)malloc( sizeof( info_t ) ) ) == NULL )
-        {
-            vlc_mutex_unlock( &p_i->lock );
+        if( ( p_info = malloc( sizeof( *p_info ) ) ) == NULL )
             return VLC_ENOMEM;
-        }
+
         INSERT_ELEM( p_cat->pp_infos, p_cat->i_infos, p_cat->i_infos, p_info );
         p_info->psz_name = strdup( psz_name );
     }
@@ -477,41 +553,173 @@ int input_item_AddInfo( input_item_t *p_i,
         free( p_info->psz_value );
     }
 
-    va_start( args, psz_format );
-    if( vasprintf( &p_info->psz_value, psz_format, args) == -1 )
+    if( vasprintf( &p_info->psz_value, psz_format, args ) == -1 )
         p_info->psz_value = NULL;
+
+    return p_info->psz_value ? VLC_SUCCESS : VLC_ENOMEM;
+}
+
+static int InputItemAddInfo( input_item_t *p_i,
+                             const char *psz_cat,
+                             const char *psz_name,
+                             const char *psz_format, ... )
+{
+    va_list args;
+
+    va_start( args, psz_format );
+    const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
+    va_end( args );
+
+    return i_ret;
+}
+
+int input_item_AddInfo( input_item_t *p_i,
+                        const char *psz_cat,
+                        const char *psz_name,
+                        const char *psz_format, ... )
+{
+    va_list args;
+
+    vlc_mutex_lock( &p_i->lock );
+
+    va_start( args, psz_format );
+    const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
     va_end( args );
 
     vlc_mutex_unlock( &p_i->lock );
 
-    return p_info->psz_value ? VLC_SUCCESS : VLC_ENOMEM;
+
+    if( !i_ret )
+    {
+        vlc_event_t event;
+
+        event.type = vlc_InputItemInfoChanged;
+        vlc_event_send( &p_i->event_manager, &event );
+    }
+    return i_ret;
 }
 
-input_item_t *__input_item_GetById( vlc_object_t *p_obj, int i_id )
+int input_item_DelInfo( input_item_t *p_i,
+                        const char *psz_cat,
+                        const char *psz_name )
 {
-    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
-    input_item_t * p_ret = NULL;
+    info_category_t *p_cat = NULL;
+    int i_cat;
     int i;
 
-    vlc_object_lock( p_obj->p_libvlc );
+    vlc_mutex_lock( &p_i->lock );
+    for( i_cat = 0; i_cat < p_i->i_categories; i_cat++ )
+    {
+        if( !strcmp( p_i->pp_categories[i_cat]->psz_name,
+                     psz_cat ) )
+        {
+            p_cat = p_i->pp_categories[i_cat];
+            break;
+        }
+    }
+    if( p_cat == NULL )
+    {
+        vlc_mutex_unlock( &p_i->lock );
+        return VLC_EGENERIC;
+    }
 
-    ARRAY_BSEARCH( priv->input_items, ->i_id, int, i_id, i);
-    if( i != -1 )
-        p_ret = ARRAY_VAL( priv->input_items, i);
+    if( psz_name )
+    {
+        /* Remove a specific info */
+        for( i = 0; i < p_cat->i_infos; i++ )
+        {
+            if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
+            {
+                free( p_cat->pp_infos[i]->psz_name );
+                free( p_cat->pp_infos[i]->psz_value );
+                free( p_cat->pp_infos[i] );
+                REMOVE_ELEM( p_cat->pp_infos, p_cat->i_infos, i );
+                break;
+            }
+        }
+        if( i >= p_cat->i_infos )
+        {
+            vlc_mutex_unlock( &p_i->lock );
+            return VLC_EGENERIC;
+        }
+    }
+    else
+    {
+        /* Remove the complete categorie */
+        for( i = 0; i < p_cat->i_infos; i++ )
+        {
+            free( p_cat->pp_infos[i]->psz_name );
+            free( p_cat->pp_infos[i]->psz_value );
+            free( p_cat->pp_infos[i] );
+        }
+        free( p_cat->pp_infos );
+        REMOVE_ELEM( p_i->pp_categories, p_i->i_categories, i_cat );
+    }
+
+    // Free the category
+    free( p_cat->psz_name );
+    free( p_cat );
+    vlc_mutex_unlock( &p_i->lock );
+
+
+    vlc_event_t event;
+    event.type = vlc_InputItemInfoChanged;
+    vlc_event_send( &p_i->event_manager, &event );
+
+    return VLC_SUCCESS;
+}
+
+void input_item_SetEpg( input_item_t *p_item,
+                        const char *psz_epg, const vlc_epg_t *p_epg )
+{
+    input_item_DelInfo( p_item, psz_epg, NULL );
+
+#ifdef HAVE_LOCALTIME_R
+    vlc_mutex_lock( &p_item->lock );
+    for( int i = 0; i < p_epg->i_event; i++ )
+    {
+        const vlc_epg_event_t *p_evt = p_epg->pp_event[i];
+        time_t t_start = (time_t)p_evt->i_start;
+        struct tm tm_start;
+        char psz_start[128];
+
+        localtime_r( &t_start, &tm_start );
+
+        snprintf( psz_start, sizeof(psz_start), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
+                  1900 + tm_start.tm_year, 1 + tm_start.tm_mon, tm_start.tm_mday,
+                  tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec );
+        if( p_evt->psz_short_description || p_evt->psz_description )
+            InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s",
+                              p_evt->psz_name,
+                              p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
+                              p_evt->psz_short_description ? p_evt->psz_short_description : p_evt->psz_description );
+        else
+            InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d)",
+                              p_evt->psz_name,
+                              p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 );
+    }
+    vlc_mutex_unlock( &p_item->lock );
 
-    vlc_object_unlock( p_obj->p_libvlc );
+    if( p_epg->i_event > 0 )
+    {
+        vlc_event_t event;
 
-    return p_ret;
+        event.type = vlc_InputItemInfoChanged;
+        vlc_event_send( &p_item->event_manager, &event );
+    }
+#endif
 }
 
+
 input_item_t *__input_item_NewExt( vlc_object_t *p_obj, const char *psz_uri,
                                   const char *psz_name,
                                   int i_options,
                                   const char *const *ppsz_options,
+                                  unsigned i_option_flags,
                                   mtime_t i_duration )
 {
     return input_item_NewWithType( p_obj, psz_uri, psz_name,
-                                  i_options, ppsz_options,
+                                  i_options, ppsz_options, i_option_flags,
                                   i_duration, ITEM_TYPE_UNKNOWN );
 }
 
@@ -520,51 +728,42 @@ input_item_t *input_item_NewWithType( vlc_object_t *p_obj, const char *psz_uri,
                                 const char *psz_name,
                                 int i_options,
                                 const char *const *ppsz_options,
+                                unsigned i_option_flags,
                                 mtime_t i_duration,
                                 int i_type )
 {
     libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
+    static vlc_mutex_t input_id_lock = VLC_STATIC_MUTEX;
 
-    DECMALLOC_NULL( p_input, input_item_t );
+    input_item_t* p_input = malloc( sizeof(input_item_t ) );
+    if( !p_input )
+        return NULL;
 
     input_item_Init( p_obj, p_input );
-    vlc_gc_init( p_input, input_item_Destroy, (void *)p_obj->p_libvlc );
+    vlc_gc_init( p_input, input_item_Destroy );
 
-    vlc_object_lock( p_obj->p_libvlc );
+    vlc_mutex_lock( &input_id_lock );
     p_input->i_id = ++priv->i_last_input_id;
-    ARRAY_APPEND( priv->input_items, p_input );
-    vlc_object_unlock( p_obj->p_libvlc );
+    vlc_mutex_unlock( &input_id_lock );
 
     p_input->b_fixed_name = false;
 
-    if( psz_uri )
-        p_input->psz_uri = strdup( psz_uri );
-    else
-        p_input->psz_uri = NULL;
-
     p_input->i_type = i_type;
     p_input->b_prefers_tree = false;
 
-    if( p_input->i_type == ITEM_TYPE_UNKNOWN )
-        GuessType( p_input );
+    if( psz_uri )
+        input_item_SetURI( p_input, psz_uri );
 
-    if( psz_name != NULL )
-        p_input->psz_name = strdup( psz_name );
-    else if( p_input->i_type == ITEM_TYPE_FILE && p_input->psz_uri )
-    {
-        const char *psz_filename = strrchr( p_input->psz_uri, DIR_SEP_CHAR );
-        if( psz_filename && *psz_filename == DIR_SEP_CHAR )
-            psz_filename++;
-        p_input->psz_name = strdup( psz_filename && *psz_filename
-                                    ? psz_filename : p_input->psz_uri );
-    }
-    else
-        p_input->psz_name = p_input->psz_uri ? strdup( p_input->psz_uri ) : NULL;
+    if( i_type != ITEM_TYPE_UNKNOWN )
+        p_input->i_type = i_type;
+
+    if( psz_name )
+        input_item_SetName( p_input, psz_name );
 
     p_input->i_duration = i_duration;
 
     for( int i = 0; i < i_options; i++ )
-        input_item_AddOption( p_input, ppsz_options[i] );
+        input_item_AddOption( p_input, ppsz_options[i], i_option_flags );
     return p_input;
 }