git.sesse.net Git - vlc/blob - src/input/item.c

   1 /*****************************************************************************
   2  * item.c: input_item management
   3  *****************************************************************************
   4  * Copyright (C) 1998-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Clément Stenac <zorglub@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write to the Free Software Foundation, Inc.,
  21  * 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27 #include <assert.h>
  28
  29 #include <vlc_common.h>
  30 #include <vlc_url.h>
  31 #include "vlc_playlist.h"
  32 #include "vlc_interface.h"
  33
  34 #include "item.h"
  35
  36 static int GuessType( const input_item_t *p_item );
  37
  38 /** Stuff moved out of vlc_input.h -- FIXME: should probably not be inline
  39  * anyway. */
  40 static inline void input_item_Init( vlc_object_t *p_o, input_item_t *p_i )
  41 {
  42     memset( p_i, 0, sizeof(input_item_t) );
  43
  44     p_i->psz_name = NULL;
  45     p_i->psz_uri = NULL;
  46     TAB_INIT( p_i->i_es, p_i->es );
  47     TAB_INIT( p_i->i_options, p_i->ppsz_options );
  48     p_i->optflagv = NULL, p_i->optflagc = 0;
  49     TAB_INIT( p_i->i_categories, p_i->pp_categories );
  50
  51     p_i->i_type = ITEM_TYPE_UNKNOWN;
  52     p_i->b_fixed_name = true;
  53
  54     p_i->p_stats = NULL;
  55     p_i->p_meta = NULL;
  56
  57     vlc_mutex_init( &p_i->lock );
  58     vlc_event_manager_t * p_em = &p_i->event_manager;
  59     vlc_event_manager_init( p_em, p_i, p_o );
  60     vlc_event_manager_register_event_type( p_em, vlc_InputItemMetaChanged );
  61     vlc_event_manager_register_event_type( p_em, vlc_InputItemSubItemAdded );
  62     vlc_event_manager_register_event_type( p_em, vlc_InputItemDurationChanged );
  63     vlc_event_manager_register_event_type( p_em, vlc_InputItemPreparsedChanged );
  64     vlc_event_manager_register_event_type( p_em, vlc_InputItemNameChanged );
  65     vlc_event_manager_register_event_type( p_em, vlc_InputItemInfoChanged );
  66     vlc_event_manager_register_event_type( p_em, vlc_InputItemErrorWhenReadingChanged );
  67 }
  68
  69 static inline void input_item_Clean( input_item_t *p_i )
  70 {
  71     int i;
  72
  73     vlc_event_manager_fini( &p_i->event_manager );
  74
  75     free( p_i->psz_name );
  76     free( p_i->psz_uri );
  77     if( p_i->p_stats )
  78     {
  79         vlc_mutex_destroy( &p_i->p_stats->lock );
  80         free( p_i->p_stats );
  81     }
  82
  83     if( p_i->p_meta )
  84         vlc_meta_Delete( p_i->p_meta );
  85
  86     for( i = 0; i < p_i->i_options; i++ )
  87         free( p_i->ppsz_options[i] );
  88     TAB_CLEAN( p_i->i_options, p_i->ppsz_options );
  89     free( p_i->optflagv);
  90
  91     for( i = 0; i < p_i->i_es; i++ )
  92     {
  93         es_format_Clean( p_i->es[i] );
  94         free( p_i->es[i] );
  95     }
  96     TAB_CLEAN( p_i->i_es, p_i->es );
  97
  98     for( i = 0; i < p_i->i_categories; i++ )
  99     {
 100         info_category_t *p_category = p_i->pp_categories[i];
 101         int j;
 102
 103         for( j = 0; j < p_category->i_infos; j++ )
 104         {
 105             struct info_t *p_info = p_category->pp_infos[j];
 106
 107             free( p_info->psz_name);
 108             free( p_info->psz_value );
 109             free( p_info );
 110         }
 111         TAB_CLEAN( p_category->i_infos, p_category->pp_infos );
 112
 113         free( p_category->psz_name );
 114         free( p_category );
 115     }
 116     TAB_CLEAN( p_i->i_categories, p_i->pp_categories );
 117
 118     vlc_mutex_destroy( &p_i->lock );
 119 }
 120 void input_item_SetErrorWhenReading( input_item_t *p_i, bool b_error )
 121 {
 122     bool b_changed;
 123
 124     vlc_mutex_lock( &p_i->lock );
 125
 126     b_changed = p_i->b_error_when_reading != b_error;
 127     p_i->b_error_when_reading = b_error;
 128
 129     vlc_mutex_unlock( &p_i->lock );
 130
 131     if( b_changed )
 132     {
 133         vlc_event_t event;
 134
 135         event.type = vlc_InputItemErrorWhenReadingChanged;
 136         event.u.input_item_error_when_reading_changed.new_value = b_error;
 137         vlc_event_send( &p_i->event_manager, &event );
 138     }
 139 }
 140 void input_item_SetPreparsed( input_item_t *p_i, bool b_preparsed )
 141 {
 142     bool b_send_event = false;
 143
 144     vlc_mutex_lock( &p_i->lock );
 145
 146     if( !p_i->p_meta )
 147         p_i->p_meta = vlc_meta_New();
 148
 149     int i_new_status;
 150     if( b_preparsed )
 151         i_new_status = p_i->p_meta->i_status | ITEM_PREPARSED;
 152     else
 153         i_new_status = p_i->p_meta->i_status & ~ITEM_PREPARSED;
 154     if( p_i->p_meta->i_status != i_new_status )
 155     {
 156         p_i->p_meta->i_status = i_new_status;
 157         b_send_event = true;
 158     }
 159
 160     vlc_mutex_unlock( &p_i->lock );
 161
 162     if( b_send_event )
 163     {
 164         vlc_event_t event;
 165         event.type = vlc_InputItemPreparsedChanged;
 166         event.u.input_item_preparsed_changed.new_status = i_new_status;
 167         vlc_event_send( &p_i->event_manager, &event );
 168     }
 169 }
 170 void input_item_SetArtNotFound( input_item_t *p_i, bool b_not_found )
 171 {
 172     vlc_mutex_lock( &p_i->lock );
 173
 174     if( !p_i->p_meta )
 175         p_i->p_meta = vlc_meta_New();
 176
 177     if( b_not_found )
 178         p_i->p_meta->i_status |= ITEM_ART_NOTFOUND;
 179     else
 180         p_i->p_meta->i_status &= ~ITEM_ART_NOTFOUND;
 181
 182     vlc_mutex_unlock( &p_i->lock );
 183 }
 184 void input_item_SetArtFetched( input_item_t *p_i, bool b_art_fetched )
 185 {
 186     vlc_mutex_lock( &p_i->lock );
 187
 188     if( !p_i->p_meta )
 189         p_i->p_meta = vlc_meta_New();
 190
 191     if( b_art_fetched )
 192         p_i->p_meta->i_status |= ITEM_ART_FETCHED;
 193     else
 194         p_i->p_meta->i_status &= ~ITEM_ART_FETCHED;
 195
 196     vlc_mutex_unlock( &p_i->lock );
 197 }
 198
 199 void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val )
 200 {
 201     vlc_event_t event;
 202
 203     vlc_mutex_lock( &p_i->lock );
 204     if( !p_i->p_meta )
 205         p_i->p_meta = vlc_meta_New();
 206     vlc_meta_Set( p_i->p_meta, meta_type, psz_val );
 207     vlc_mutex_unlock( &p_i->lock );
 208
 209     /* Notify interested third parties */
 210     event.type = vlc_InputItemMetaChanged;
 211     event.u.input_item_meta_changed.meta_type = meta_type;
 212     vlc_event_send( &p_i->event_manager, &event );
 213 }
 214
 215 /* FIXME GRRRRRRRRRR args should be in the reverse order to be
 216  * consistant with (nearly?) all or copy funcs */
 217 void input_item_CopyOptions( input_item_t *p_parent,
 218                              input_item_t *p_child )
 219 {
 220     vlc_mutex_lock( &p_parent->lock );
 221
 222     for( int i = 0 ; i< p_parent->i_options; i++ )
 223     {
 224         if( !strcmp( p_parent->ppsz_options[i], "meta-file" ) )
 225             continue;
 226
 227         input_item_AddOption( p_child,
 228                               p_parent->ppsz_options[i],
 229                               p_parent->optflagv[i] );
 230     }
 231
 232     vlc_mutex_unlock( &p_parent->lock );
 233 }
 234
 235 /* This won't hold the item, but can tell to interested third parties
 236  * Like the playlist, that there is a new sub item. With this design
 237  * It is not the input item's responsability to keep all the ref of
 238  * the input item children. */
 239 void input_item_AddSubItem( input_item_t *p_parent, input_item_t *p_child )
 240 {
 241     vlc_mutex_lock( &p_parent->lock );
 242
 243     p_parent->i_type = ITEM_TYPE_PLAYLIST;
 244
 245     vlc_mutex_unlock( &p_parent->lock );
 246
 247     /* Notify interested third parties */
 248     vlc_event_t event;
 249
 250     event.type = vlc_InputItemSubItemAdded;
 251     event.u.input_item_subitem_added.p_new_child = p_child;
 252     vlc_event_send( &p_parent->event_manager, &event );
 253 }
 254
 255 bool input_item_HasErrorWhenReading( input_item_t *p_item )
 256 {
 257     vlc_mutex_lock( &p_item->lock );
 258
 259     bool b_error = p_item->b_error_when_reading;
 260
 261     vlc_mutex_unlock( &p_item->lock );
 262
 263     return b_error;
 264 }
 265
 266 bool input_item_MetaMatch( input_item_t *p_i,
 267                            vlc_meta_type_t meta_type, const char *psz )
 268 {
 269     vlc_mutex_lock( &p_i->lock );
 270
 271     if( !p_i->p_meta )
 272     {
 273         vlc_mutex_unlock( &p_i->lock );
 274         return false;
 275     }
 276     const char *psz_meta = vlc_meta_Get( p_i->p_meta, meta_type );
 277     bool b_ret = psz_meta && strcasestr( psz_meta, psz );
 278
 279     vlc_mutex_unlock( &p_i->lock );
 280
 281     return b_ret;
 282 }
 283
 284 char *input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
 285 {
 286     vlc_mutex_lock( &p_i->lock );
 287
 288     if( !p_i->p_meta )
 289     {
 290         vlc_mutex_unlock( &p_i->lock );
 291         return NULL;
 292     }
 293
 294     char *psz = NULL;
 295     if( vlc_meta_Get( p_i->p_meta, meta_type ) )
 296         psz = strdup( vlc_meta_Get( p_i->p_meta, meta_type ) );
 297
 298     vlc_mutex_unlock( &p_i->lock );
 299     return psz;
 300 }
 301
 302 /* Get the title of a given item or fallback to the name if the title is empty */
 303 char *input_item_GetTitleFbName( input_item_t *p_item )
 304 {
 305     char *psz_ret;
 306     vlc_mutex_lock( &p_item->lock );
 307
 308     if( !p_item->p_meta )
 309     {
 310         psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
 311         vlc_mutex_unlock( &p_item->lock );
 312         return psz_ret;
 313     }
 314
 315     const char *psz_title = vlc_meta_Get( p_item->p_meta, vlc_meta_Title );
 316     if( !EMPTY_STR( psz_title ) )
 317         psz_ret = strdup( psz_title );
 318     else
 319         psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
 320
 321     vlc_mutex_unlock( &p_item->lock );
 322     return psz_ret;
 323 }
 324
 325 char *input_item_GetName( input_item_t *p_item )
 326 {
 327     vlc_mutex_lock( &p_item->lock );
 328
 329     char *psz_name = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
 330
 331     vlc_mutex_unlock( &p_item->lock );
 332     return psz_name;
 333 }
 334 void input_item_SetName( input_item_t *p_item, const char *psz_name )
 335 {
 336     vlc_mutex_lock( &p_item->lock );
 337
 338     free( p_item->psz_name );
 339     p_item->psz_name = strdup( psz_name );
 340
 341     vlc_mutex_unlock( &p_item->lock );
 342 }
 343
 344 char *input_item_GetURI( input_item_t *p_i )
 345 {
 346     vlc_mutex_lock( &p_i->lock );
 347
 348     char *psz_s = p_i->psz_uri ? strdup( p_i->psz_uri ) : NULL;
 349
 350     vlc_mutex_unlock( &p_i->lock );
 351     return psz_s;
 352 }
 353 void input_item_SetURI( input_item_t *p_i, const char *psz_uri )
 354 {
 355     vlc_mutex_lock( &p_i->lock );
 356 #ifndef NDEBUG
 357     if( !strstr( psz_uri, "://" ) || strstr( psz_uri, " " ) || strstr( psz_uri, "\"" ) )
 358         fprintf( stderr, "input_item_SetURI() was likely called with a path. FIXME\n" );
 359 #endif
 360
 361     free( p_i->psz_uri );
 362     p_i->psz_uri = strdup( psz_uri );
 363
 364     p_i->i_type = GuessType( p_i );
 365
 366     if( p_i->psz_name )
 367         ;
 368     else
 369     if( p_i->i_type == ITEM_TYPE_FILE || p_i->i_type == ITEM_TYPE_DIRECTORY )
 370     {
 371         const char *psz_filename = strrchr( p_i->psz_uri, '/' );
 372
 373         if( psz_filename && *psz_filename == '/' )
 374             psz_filename++;
 375         if( psz_filename && *psz_filename )
 376             p_i->psz_name = strdup( psz_filename );
 377
 378         /* Make the name more readable */
 379         if( p_i->psz_name )
 380             decode_URI( p_i->psz_name );
 381     }
 382     else
 383     {   /* Strip login and password from title */
 384         int r;
 385         vlc_url_t url;
 386
 387         vlc_UrlParse( &url, psz_uri, 0 );
 388         if( url.psz_protocol )
 389         {
 390             if( url.i_port > 0 )
 391                 r=asprintf( &p_i->psz_name, "%s://%s:%d%s", url.psz_protocol,
 392                           url.psz_host, url.i_port,
 393                           url.psz_path ? url.psz_path : "" );
 394             else
 395                 r=asprintf( &p_i->psz_name, "%s://%s%s", url.psz_protocol,
 396                           url.psz_host ? url.psz_host : "",
 397                           url.psz_path ? url.psz_path : "" );
 398         }
 399         else
 400         {
 401             if( url.i_port > 0 )
 402                 r=asprintf( &p_i->psz_name, "%s:%d%s", url.psz_host, url.i_port,
 403                           url.psz_path ? url.psz_path : "" );
 404             else
 405                 r=asprintf( &p_i->psz_name, "%s%s", url.psz_host,
 406                           url.psz_path ? url.psz_path : "" );
 407         }
 408         vlc_UrlClean( &url );
 409         if( -1==r )
 410             p_i->psz_name=NULL; /* recover from undefined value */
 411
 412         /* Make the name more readable */
 413         if( p_i->psz_name )
 414             decode_URI( p_i->psz_name );
 415     }
 416
 417     vlc_mutex_unlock( &p_i->lock );
 418 }
 419
 420 mtime_t input_item_GetDuration( input_item_t *p_i )
 421 {
 422     vlc_mutex_lock( &p_i->lock );
 423
 424     mtime_t i_duration = p_i->i_duration;
 425
 426     vlc_mutex_unlock( &p_i->lock );
 427     return i_duration;
 428 }
 429
 430 void input_item_SetDuration( input_item_t *p_i, mtime_t i_duration )
 431 {
 432     bool b_send_event = false;
 433
 434     vlc_mutex_lock( &p_i->lock );
 435     if( p_i->i_duration != i_duration )
 436     {
 437         p_i->i_duration = i_duration;
 438         b_send_event = true;
 439     }
 440     vlc_mutex_unlock( &p_i->lock );
 441
 442     if( b_send_event )
 443     {
 444         vlc_event_t event;
 445
 446         event.type = vlc_InputItemDurationChanged;
 447         event.u.input_item_duration_changed.new_duration = i_duration;
 448         vlc_event_send( &p_i->event_manager, &event );
 449     }
 450 }
 451
 452
 453 bool input_item_IsPreparsed( input_item_t *p_item )
 454 {
 455     vlc_mutex_lock( &p_item->lock );
 456     bool b_preparsed = p_item->p_meta ? ( p_item->p_meta->i_status & ITEM_PREPARSED ) != 0 : false;
 457     vlc_mutex_unlock( &p_item->lock );
 458
 459     return b_preparsed;
 460 }
 461
 462 bool input_item_IsArtFetched( input_item_t *p_item )
 463 {
 464     vlc_mutex_lock( &p_item->lock );
 465     bool b_fetched = p_item->p_meta ? ( p_item->p_meta->i_status & ITEM_ART_FETCHED ) != 0 : false;
 466     vlc_mutex_unlock( &p_item->lock );
 467
 468     return b_fetched;
 469 }
 470
 471 static void input_item_Destroy ( gc_object_t *p_gc )
 472 {
 473     input_item_t *p_item = vlc_priv( p_gc, input_item_t );
 474
 475     input_item_Clean( p_item );
 476     free( p_item );
 477 }
 478
 479 int input_item_AddOption( input_item_t *p_input, const char *psz_option,
 480                           unsigned flags )
 481 {
 482     int err = VLC_SUCCESS;
 483
 484     if( psz_option == NULL )
 485         return VLC_EGENERIC;
 486
 487     vlc_mutex_lock( &p_input->lock );
 488     if (flags & VLC_INPUT_OPTION_UNIQUE)
 489     {
 490         for (int i = 0 ; i < p_input->i_options; i++)
 491             if( !strcmp( p_input->ppsz_options[i], psz_option ) )
 492                 goto out;
 493     }
 494
 495     uint8_t *flagv = realloc (p_input->optflagv, p_input->optflagc + 1);
 496     if (flagv == NULL)
 497     {
 498         err = VLC_ENOMEM;
 499         goto out;
 500     }
 501     p_input->optflagv = flagv;
 502     flagv[p_input->optflagc++] = flags;
 503
 504     INSERT_ELEM( p_input->ppsz_options, p_input->i_options,
 505                  p_input->i_options, strdup( psz_option ) );
 506 out:
 507     vlc_mutex_unlock( &p_input->lock );
 508     return err;
 509 }
 510
 511 /**
 512  * Get a info item from a given category in a given input item.
 513  *
 514  * \param p_i The input item to get info from
 515  * \param psz_cat String representing the category for the info
 516  * \param psz_name String representing the name of the desired info
 517  * \return A pointer to the string with the given info if found, or an
 518  *         empty string otherwise. The caller should free the returned
 519  *         pointer.
 520  */
 521 char *input_item_GetInfo( input_item_t *p_i,
 522                           const char *psz_cat,
 523                           const char *psz_name )
 524 {
 525     vlc_mutex_lock( &p_i->lock );
 526
 527     for( int i = 0; i< p_i->i_categories; i++ )
 528     {
 529         const info_category_t *p_cat = p_i->pp_categories[i];
 530
 531         if( !psz_cat || strcmp( p_cat->psz_name, psz_cat ) )
 532             continue;
 533
 534         for( int j = 0; j < p_cat->i_infos; j++ )
 535         {
 536             if( !strcmp( p_cat->pp_infos[j]->psz_name, psz_name ) )
 537             {
 538                 char *psz_ret = strdup( p_cat->pp_infos[j]->psz_value );
 539                 vlc_mutex_unlock( &p_i->lock );
 540                 return psz_ret;
 541             }
 542         }
 543     }
 544     vlc_mutex_unlock( &p_i->lock );
 545     return strdup( "" );
 546 }
 547
 548 static int InputItemVaAddInfo( input_item_t *p_i,
 549                                const char *psz_cat,
 550                                const char *psz_name,
 551                                const char *psz_format, va_list args )
 552 {
 553     int i;
 554     info_t *p_info = NULL;
 555     info_category_t *p_cat = NULL ;
 556
 557     vlc_assert_locked( &p_i->lock );
 558
 559     for( i = 0 ; i < p_i->i_categories ; i ++ )
 560     {
 561         if( !strcmp( p_i->pp_categories[i]->psz_name, psz_cat ) )
 562         {
 563             p_cat = p_i->pp_categories[i];
 564             break;
 565         }
 566     }
 567     if( !p_cat )
 568     {
 569         if( !(p_cat = malloc( sizeof(*p_cat) )) )
 570             return VLC_ENOMEM;
 571
 572         p_cat->psz_name = strdup( psz_cat );
 573         p_cat->i_infos = 0;
 574         p_cat->pp_infos = 0;
 575         INSERT_ELEM( p_i->pp_categories, p_i->i_categories, p_i->i_categories,
 576                      p_cat );
 577     }
 578
 579     for( i = 0; i< p_cat->i_infos; i++ )
 580     {
 581         if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
 582         {
 583             p_info = p_cat->pp_infos[i];
 584             break;
 585         }
 586     }
 587
 588     if( !p_info )
 589     {
 590         if( ( p_info = malloc( sizeof( *p_info ) ) ) == NULL )
 591             return VLC_ENOMEM;
 592
 593         INSERT_ELEM( p_cat->pp_infos, p_cat->i_infos, p_cat->i_infos, p_info );
 594         p_info->psz_name = strdup( psz_name );
 595     }
 596     else
 597     {
 598         free( p_info->psz_value );
 599     }
 600
 601     if( vasprintf( &p_info->psz_value, psz_format, args ) == -1 )
 602         p_info->psz_value = NULL;
 603
 604     return p_info->psz_value ? VLC_SUCCESS : VLC_ENOMEM;
 605 }
 606
 607 static int InputItemAddInfo( input_item_t *p_i,
 608                              const char *psz_cat,
 609                              const char *psz_name,
 610                              const char *psz_format, ... )
 611 {
 612     va_list args;
 613
 614     va_start( args, psz_format );
 615     const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
 616     va_end( args );
 617
 618     return i_ret;
 619 }
 620
 621 int input_item_AddInfo( input_item_t *p_i,
 622                         const char *psz_cat,
 623                         const char *psz_name,
 624                         const char *psz_format, ... )
 625 {
 626     va_list args;
 627
 628     vlc_mutex_lock( &p_i->lock );
 629
 630     va_start( args, psz_format );
 631     const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
 632     va_end( args );
 633
 634     vlc_mutex_unlock( &p_i->lock );
 635
 636
 637     if( !i_ret )
 638     {
 639         vlc_event_t event;
 640
 641         event.type = vlc_InputItemInfoChanged;
 642         vlc_event_send( &p_i->event_manager, &event );
 643     }
 644     return i_ret;
 645 }
 646
 647 int input_item_DelInfo( input_item_t *p_i,
 648                         const char *psz_cat,
 649                         const char *psz_name )
 650 {
 651     info_category_t *p_cat = NULL;
 652     int i_cat;
 653     int i;
 654
 655     vlc_mutex_lock( &p_i->lock );
 656     for( i_cat = 0; i_cat < p_i->i_categories; i_cat++ )
 657     {
 658         if( !strcmp( p_i->pp_categories[i_cat]->psz_name,
 659                      psz_cat ) )
 660         {
 661             p_cat = p_i->pp_categories[i_cat];
 662             break;
 663         }
 664     }
 665     if( p_cat == NULL )
 666     {
 667         vlc_mutex_unlock( &p_i->lock );
 668         return VLC_EGENERIC;
 669     }
 670
 671     if( psz_name )
 672     {
 673         /* Remove a specific info */
 674         for( i = 0; i < p_cat->i_infos; i++ )
 675         {
 676             if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
 677             {
 678                 free( p_cat->pp_infos[i]->psz_name );
 679                 free( p_cat->pp_infos[i]->psz_value );
 680                 free( p_cat->pp_infos[i] );
 681                 REMOVE_ELEM( p_cat->pp_infos, p_cat->i_infos, i );
 682                 break;
 683             }
 684         }
 685         if( i >= p_cat->i_infos )
 686         {
 687             vlc_mutex_unlock( &p_i->lock );
 688             return VLC_EGENERIC;
 689         }
 690     }
 691     else
 692     {
 693         /* Remove the complete categorie */
 694         for( i = 0; i < p_cat->i_infos; i++ )
 695         {
 696             free( p_cat->pp_infos[i]->psz_name );
 697             free( p_cat->pp_infos[i]->psz_value );
 698             free( p_cat->pp_infos[i] );
 699         }
 700         free( p_cat->pp_infos );
 701         REMOVE_ELEM( p_i->pp_categories, p_i->i_categories, i_cat );
 702     }
 703
 704     // Free the category
 705     free( p_cat->psz_name );
 706     free( p_cat );
 707     vlc_mutex_unlock( &p_i->lock );
 708
 709
 710     vlc_event_t event;
 711     event.type = vlc_InputItemInfoChanged;
 712     vlc_event_send( &p_i->event_manager, &event );
 713
 714     return VLC_SUCCESS;
 715 }
 716
 717 void input_item_SetEpg( input_item_t *p_item,
 718                         const char *psz_epg, const vlc_epg_t *p_epg )
 719 {
 720     input_item_DelInfo( p_item, psz_epg, NULL );
 721
 722 #ifdef HAVE_LOCALTIME_R
 723     vlc_mutex_lock( &p_item->lock );
 724     for( int i = 0; i < p_epg->i_event; i++ )
 725     {
 726         const vlc_epg_event_t *p_evt = p_epg->pp_event[i];
 727         time_t t_start = (time_t)p_evt->i_start;
 728         struct tm tm_start;
 729         char psz_start[128];
 730
 731         localtime_r( &t_start, &tm_start );
 732
 733         snprintf( psz_start, sizeof(psz_start), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
 734                   1900 + tm_start.tm_year, 1 + tm_start.tm_mon, tm_start.tm_mday,
 735                   tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec );
 736         if( p_evt->psz_short_description || p_evt->psz_description )
 737             InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s",
 738                               p_evt->psz_name,
 739                               p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
 740                               p_evt->psz_short_description ? p_evt->psz_short_description : p_evt->psz_description );
 741         else
 742             InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d)",
 743                               p_evt->psz_name,
 744                               p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 );
 745     }
 746     vlc_mutex_unlock( &p_item->lock );
 747
 748     if( p_epg->i_event > 0 )
 749     {
 750         vlc_event_t event;
 751
 752         event.type = vlc_InputItemInfoChanged;
 753         vlc_event_send( &p_item->event_manager, &event );
 754     }
 755 #endif
 756 }
 757
 758
 759 input_item_t *__input_item_NewExt( vlc_object_t *p_obj, const char *psz_uri,
 760                                   const char *psz_name,
 761                                   int i_options,
 762                                   const char *const *ppsz_options,
 763                                   unsigned i_option_flags,
 764                                   mtime_t i_duration )
 765 {
 766     return input_item_NewWithType( p_obj, psz_uri, psz_name,
 767                                   i_options, ppsz_options, i_option_flags,
 768                                   i_duration, ITEM_TYPE_UNKNOWN );
 769 }
 770
 771
 772 input_item_t *input_item_NewWithType( vlc_object_t *p_obj, const char *psz_uri,
 773                                 const char *psz_name,
 774                                 int i_options,
 775                                 const char *const *ppsz_options,
 776                                 unsigned i_option_flags,
 777                                 mtime_t i_duration,
 778                                 int i_type )
 779 {
 780     libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
 781     static vlc_mutex_t input_id_lock = VLC_STATIC_MUTEX;
 782
 783     input_item_t* p_input = malloc( sizeof(input_item_t ) );
 784     if( !p_input )
 785         return NULL;
 786
 787     input_item_Init( p_obj, p_input );
 788     vlc_gc_init( p_input, input_item_Destroy );
 789
 790     vlc_mutex_lock( &input_id_lock );
 791     p_input->i_id = ++priv->i_last_input_id;
 792     vlc_mutex_unlock( &input_id_lock );
 793
 794     p_input->b_fixed_name = false;
 795
 796     p_input->i_type = i_type;
 797     p_input->b_prefers_tree = false;
 798
 799     if( psz_uri )
 800         input_item_SetURI( p_input, psz_uri );
 801
 802     if( i_type != ITEM_TYPE_UNKNOWN )
 803         p_input->i_type = i_type;
 804
 805     if( psz_name )
 806         input_item_SetName( p_input, psz_name );
 807
 808     p_input->i_duration = i_duration;
 809
 810     for( int i = 0; i < i_options; i++ )
 811         input_item_AddOption( p_input, ppsz_options[i], i_option_flags );
 812     return p_input;
 813 }
 814
 815 struct item_type_entry
 816 {
 817     const char psz_scheme[7];
 818     uint8_t    i_type;
 819 };
 820
 821 static int typecmp( const void *key, const void *entry )
 822 {
 823     const struct item_type_entry *type = entry;
 824     const char *uri = key, *scheme = type->psz_scheme;
 825
 826     return strncmp( uri, scheme, strlen( scheme ) );
 827 }
 828
 829 /* Guess the type of the item using the beginning of the mrl */
 830 static int GuessType( const input_item_t *p_item )
 831 {
 832     static const struct item_type_entry tab[] =
 833     {   /* /!\ Alphabetical order /!\ */
 834         /* Short match work, not just exact match */
 835         { "alsa",   ITEM_TYPE_CARD },
 836         { "atsc",   ITEM_TYPE_CARD },
 837         { "bd",     ITEM_TYPE_DISC },
 838         { "cable",  ITEM_TYPE_CARD },
 839         { "cdda",   ITEM_TYPE_CDDA },
 840         { "dc1394", ITEM_TYPE_CARD },
 841         { "dccp",   ITEM_TYPE_NET },
 842         { "dir",    ITEM_TYPE_DIRECTORY },
 843         { "dshow",  ITEM_TYPE_CARD },
 844         { "dv",     ITEM_TYPE_CARD },
 845         { "dvb",    ITEM_TYPE_CARD },
 846         { "dvd",    ITEM_TYPE_DISC },
 847         { "ftp",    ITEM_TYPE_NET },
 848         { "http",   ITEM_TYPE_NET },
 849         { "icyx",   ITEM_TYPE_NET },
 850         { "itpc",   ITEM_TYPE_NET },
 851         { "jack",   ITEM_TYPE_CARD },
 852         { "live",   ITEM_TYPE_NET }, /* livedotcom */
 853         { "mms",    ITEM_TYPE_NET },
 854         { "mtp",    ITEM_TYPE_DISC },
 855         { "ofdm",   ITEM_TYPE_CARD },
 856         { "oss",    ITEM_TYPE_CARD },
 857         { "pnm",    ITEM_TYPE_NET },
 858         { "pvr",    ITEM_TYPE_CARD },
 859         { "qam",    ITEM_TYPE_CARD },
 860         { "qpsk",   ITEM_TYPE_CARD },
 861         { "qtcapt", ITEM_TYPE_CARD }, /* qtcapture */
 862         { "raw139", ITEM_TYPE_CARD }, /* raw1394 */
 863         { "rt",     ITEM_TYPE_NET }, /* rtp, rtsp, rtmp */
 864         { "satell", ITEM_TYPE_CARD }, /* sattelite */
 865         { "screen", ITEM_TYPE_CARD },
 866         { "sdp",    ITEM_TYPE_NET },
 867         { "smb",    ITEM_TYPE_NET },
 868         { "svcd",   ITEM_TYPE_DISC },
 869         { "tcp",    ITEM_TYPE_NET },
 870         { "terres", ITEM_TYPE_CARD }, /* terrestrial */
 871         { "udp",    ITEM_TYPE_NET },  /* udplite too */
 872         { "unsv",   ITEM_TYPE_NET },
 873         { "usdigi", ITEM_TYPE_CARD }, /* usdigital */
 874         { "v4l",    ITEM_TYPE_CARD },
 875         { "vcd",    ITEM_TYPE_DISC },
 876         { "window", ITEM_TYPE_CARD },
 877     };
 878     const struct item_type_entry *e;
 879
 880     if( !strstr( p_item->psz_uri, "://" ) )
 881         return ITEM_TYPE_FILE;
 882
 883     e = bsearch( p_item->psz_uri, tab, sizeof( tab ) / sizeof( tab[0] ),
 884                  sizeof( tab[0] ), typecmp );
 885     return e ? e->i_type : ITEM_TYPE_FILE;
 886 }