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