1 /*****************************************************************************
2 * item.c: input_item management
3 *****************************************************************************
4 * Copyright (C) 1998-2004 the VideoLAN team
7 * Authors: Clément Stenac <zorglub@videolan.org>
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.
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.
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 *****************************************************************************/
29 #include <vlc_common.h>
30 #include "vlc_playlist.h"
31 #include "vlc_interface.h"
33 #include "input_internal.h"
35 static void GuessType( input_item_t *p_item );
37 /** Stuff moved out of vlc_input.h -- FIXME: should probably not be inline
39 static inline void input_item_Init( vlc_object_t *p_o, input_item_t *p_i )
41 memset( p_i, 0, sizeof(input_item_t) );
44 TAB_INIT( p_i->i_es, p_i->es );
45 TAB_INIT( p_i->i_options, p_i->ppsz_options );
46 p_i->optflagv = NULL, p_i->optflagc = 0;
47 TAB_INIT( p_i->i_categories, p_i->pp_categories );
49 p_i->i_type = ITEM_TYPE_UNKNOWN;
50 p_i->b_fixed_name = true;
55 vlc_mutex_init( &p_i->lock );
56 vlc_event_manager_t * p_em = &p_i->event_manager;
57 vlc_event_manager_init( p_em, p_i, p_o );
58 vlc_event_manager_register_event_type( p_em, vlc_InputItemMetaChanged );
59 vlc_event_manager_register_event_type( p_em, vlc_InputItemSubItemAdded );
60 vlc_event_manager_register_event_type( p_em, vlc_InputItemDurationChanged );
61 vlc_event_manager_register_event_type( p_em, vlc_InputItemPreparsedChanged );
62 vlc_event_manager_register_event_type( p_em, vlc_InputItemNameChanged );
63 vlc_event_manager_register_event_type( p_em, vlc_InputItemInfoChanged );
64 vlc_event_manager_register_event_type( p_em, vlc_InputItemErrorWhenReadingChanged );
67 static inline void input_item_Clean( input_item_t *p_i )
71 vlc_event_manager_fini( &p_i->event_manager );
73 free( p_i->psz_name );
77 vlc_mutex_destroy( &p_i->p_stats->lock );
82 vlc_meta_Delete( p_i->p_meta );
84 for( i = 0; i < p_i->i_options; i++ )
85 free( p_i->ppsz_options[i] );
86 TAB_CLEAN( p_i->i_options, p_i->ppsz_options );
89 for( i = 0; i < p_i->i_es; i++ )
91 es_format_Clean( p_i->es[i] );
94 TAB_CLEAN( p_i->i_es, p_i->es );
96 for( i = 0; i < p_i->i_categories; i++ )
98 info_category_t *p_category = p_i->pp_categories[i];
101 for( j = 0; j < p_category->i_infos; j++ )
103 struct info_t *p_info = p_category->pp_infos[j];
105 free( p_info->psz_name);
106 free( p_info->psz_value );
109 TAB_CLEAN( p_category->i_infos, p_category->pp_infos );
111 free( p_category->psz_name );
114 TAB_CLEAN( p_i->i_categories, p_i->pp_categories );
116 vlc_mutex_destroy( &p_i->lock );
119 void input_item_SetHasErrorWhenReading( input_item_t *p_i, bool error )
123 if( p_i->b_error_when_reading == error )
126 p_i->b_error_when_reading = error;
128 /* Notify interested third parties */
129 event.type = vlc_InputItemErrorWhenReadingChanged;
130 event.u.input_item_error_when_reading_changed.new_value = error;
131 vlc_event_send( &p_i->event_manager, &event );
134 void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val )
138 vlc_mutex_lock( &p_i->lock );
140 p_i->p_meta = vlc_meta_New();
141 vlc_meta_Set( p_i->p_meta, meta_type, psz_val );
142 vlc_mutex_unlock( &p_i->lock );
144 /* Notify interested third parties */
145 event.type = vlc_InputItemMetaChanged;
146 event.u.input_item_meta_changed.meta_type = meta_type;
147 vlc_event_send( &p_i->event_manager, &event );
151 * Get the item from an input thread
153 input_item_t *input_GetItem( input_thread_t *p_input )
155 assert( p_input && p_input->p );
156 return p_input->p->input.p_item;
159 void input_item_CopyOptions( input_item_t *p_parent,
160 input_item_t *p_child )
163 for( i = 0 ; i< p_parent->i_options; i++ )
165 char *psz_option= strdup( p_parent->ppsz_options[i] );
166 if( !strcmp( psz_option, "meta-file" ) )
171 p_child->i_options++;
172 p_child->ppsz_options = (char **)realloc( p_child->ppsz_options,
175 p_child->ppsz_options[p_child->i_options-1] = psz_option;
177 p_child->optflagv = (uint8_t *)realloc( p_child->optflagv,
179 p_child->optflagv[p_child->optflagc - 1] = p_parent->optflagv[i];
183 void input_item_SetName( input_item_t *p_item, const char *psz_name )
185 free( p_item->psz_name );
186 p_item->psz_name = strdup( psz_name );
189 /* This won't hold the item, but can tell to interested third parties
190 * Like the playlist, that there is a new sub item. With this design
191 * It is not the input item's responsability to keep all the ref of
192 * the input item children. */
193 void input_item_AddSubItem( input_item_t *p_parent,
194 input_item_t *p_child )
198 p_parent->i_type = ITEM_TYPE_PLAYLIST;
200 /* Notify interested third parties */
201 event.type = vlc_InputItemSubItemAdded;
202 event.u.input_item_subitem_added.p_new_child = p_child;
203 vlc_event_send( &p_parent->event_manager, &event );
206 int input_item_AddOption (input_item_t *item, const char *str)
208 return input_item_AddOpt (item, str, VLC_INPUT_OPTION_TRUSTED);
211 bool input_item_HasErrorWhenReading (input_item_t *item)
213 return item->b_error_when_reading;
216 bool input_item_MetaMatch( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz )
218 vlc_mutex_lock( &p_i->lock );
221 vlc_mutex_unlock( &p_i->lock );
224 const char * meta = vlc_meta_Get( p_i->p_meta, meta_type );
225 bool ret = meta && strcasestr( meta, psz );
226 vlc_mutex_unlock( &p_i->lock );
231 char * input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
234 vlc_mutex_lock( &p_i->lock );
238 vlc_mutex_unlock( &p_i->lock );
242 if( vlc_meta_Get( p_i->p_meta, meta_type ) )
243 psz = strdup( vlc_meta_Get( p_i->p_meta, meta_type ) );
245 vlc_mutex_unlock( &p_i->lock );
249 char * input_item_GetName( input_item_t * p_i )
251 vlc_mutex_lock( &p_i->lock );
252 char *psz_s = p_i->psz_name ? strdup( p_i->psz_name ) : NULL;
253 vlc_mutex_unlock( &p_i->lock );
257 char * input_item_GetURI( input_item_t * p_i )
259 vlc_mutex_lock( &p_i->lock );
260 char *psz_s = p_i->psz_uri ? strdup( p_i->psz_uri ) : NULL;
261 vlc_mutex_unlock( &p_i->lock );
265 void input_item_SetURI( input_item_t * p_i, char * psz_uri )
267 vlc_mutex_lock( &p_i->lock );
268 free( p_i->psz_uri );
269 p_i->psz_uri = strdup( psz_uri );
270 vlc_mutex_unlock( &p_i->lock );
273 mtime_t input_item_GetDuration( input_item_t * p_i )
275 vlc_mutex_lock( &p_i->lock );
276 mtime_t i_duration = p_i->i_duration;
277 vlc_mutex_unlock( &p_i->lock );
281 void input_item_SetDuration( input_item_t * p_i, mtime_t i_duration )
283 bool send_event = false;
285 vlc_mutex_lock( &p_i->lock );
286 if( p_i->i_duration != i_duration )
288 p_i->i_duration = i_duration;
291 vlc_mutex_unlock( &p_i->lock );
293 if ( send_event == true )
296 event.type = vlc_InputItemDurationChanged;
297 event.u.input_item_duration_changed.new_duration = i_duration;
298 vlc_event_send( &p_i->event_manager, &event );
305 bool input_item_IsPreparsed( input_item_t *p_i )
307 return p_i->p_meta ? p_i->p_meta->i_status & ITEM_PREPARSED : false ;
310 bool input_item_IsArtFetched( input_item_t *p_i )
312 return p_i->p_meta ? p_i->p_meta->i_status & ITEM_ART_FETCHED : false ;
315 const vlc_meta_t * input_item_GetMetaObject( input_item_t *p_i )
318 p_i->p_meta = vlc_meta_New();
323 void input_item_MetaMerge( input_item_t *p_i, const vlc_meta_t * p_new_meta )
326 p_i->p_meta = vlc_meta_New();
328 vlc_meta_Merge( p_i->p_meta, p_new_meta );
332 * Get a info item from a given category in a given input item.
334 * \param p_i The input item to get info from
335 * \param psz_cat String representing the category for the info
336 * \param psz_name String representing the name of the desired info
337 * \return A pointer to the string with the given info if found, or an
338 * empty string otherwise. The caller should free the returned
341 char *input_item_GetInfo( input_item_t *p_i,
343 const char *psz_name )
347 vlc_mutex_lock( &p_i->lock );
349 for( i = 0 ; i< p_i->i_categories ; i++ )
351 info_category_t *p_cat = p_i->pp_categories[i];
353 if( !psz_cat || strcmp( p_cat->psz_name, psz_cat ) )
356 for( j = 0; j < p_cat->i_infos ; j++ )
358 if( !strcmp( p_cat->pp_infos[j]->psz_name, psz_name ) )
360 char *psz_ret = strdup( p_cat->pp_infos[j]->psz_value );
361 vlc_mutex_unlock( &p_i->lock );
366 vlc_mutex_unlock( &p_i->lock );
370 static void input_item_Destroy ( gc_object_t *gc )
372 input_item_t *p_input = vlc_priv(gc, input_item_t);
374 input_item_Clean( p_input );
378 int input_item_AddOpt( input_item_t *p_input, const char *psz_option,
381 int err = VLC_SUCCESS;
383 if( psz_option == NULL )
386 vlc_mutex_lock( &p_input->lock );
387 if (flags & VLC_INPUT_OPTION_UNIQUE)
389 for (int i = 0 ; i < p_input->i_options; i++)
390 if( !strcmp( p_input->ppsz_options[i], psz_option ) )
394 uint8_t *flagv = realloc (p_input->optflagv, p_input->optflagc + 1);
400 p_input->optflagv = flagv;
401 flagv[p_input->optflagc++] = flags;
403 INSERT_ELEM( p_input->ppsz_options, p_input->i_options,
404 p_input->i_options, strdup( psz_option ) );
406 vlc_mutex_unlock( &p_input->lock );
410 int input_item_AddInfo( input_item_t *p_i,
412 const char *psz_name,
413 const char *psz_format, ... )
417 info_t *p_info = NULL;
418 info_category_t *p_cat = NULL ;
420 vlc_mutex_lock( &p_i->lock );
422 for( i = 0 ; i < p_i->i_categories ; i ++ )
424 if( !strcmp( p_i->pp_categories[i]->psz_name, psz_cat ) )
426 p_cat = p_i->pp_categories[i];
432 if( !(p_cat = (info_category_t *)malloc( sizeof(info_category_t) )) )
434 vlc_mutex_unlock( &p_i->lock );
437 p_cat->psz_name = strdup( psz_cat );
440 INSERT_ELEM( p_i->pp_categories, p_i->i_categories, p_i->i_categories,
444 for( i = 0; i< p_cat->i_infos; i++ )
446 if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
448 p_info = p_cat->pp_infos[i];
455 if( ( p_info = (info_t *)malloc( sizeof( info_t ) ) ) == NULL )
457 vlc_mutex_unlock( &p_i->lock );
460 INSERT_ELEM( p_cat->pp_infos, p_cat->i_infos, p_cat->i_infos, p_info );
461 p_info->psz_name = strdup( psz_name );
465 free( p_info->psz_value );
468 va_start( args, psz_format );
469 if( vasprintf( &p_info->psz_value, psz_format, args) == -1 )
470 p_info->psz_value = NULL;
473 vlc_mutex_unlock( &p_i->lock );
475 return p_info->psz_value ? VLC_SUCCESS : VLC_ENOMEM;
478 input_item_t *__input_item_NewExt( vlc_object_t *p_obj, const char *psz_uri,
479 const char *psz_name,
481 const char *const *ppsz_options,
484 return input_item_NewWithType( p_obj, psz_uri, psz_name,
485 i_options, ppsz_options,
486 i_duration, ITEM_TYPE_UNKNOWN );
490 input_item_t *input_item_NewWithType( vlc_object_t *p_obj, const char *psz_uri,
491 const char *psz_name,
493 const char *const *ppsz_options,
497 libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
499 DECMALLOC_NULL( p_input, input_item_t );
501 input_item_Init( p_obj, p_input );
502 vlc_gc_init( p_input, input_item_Destroy );
504 vlc_object_lock( p_obj->p_libvlc );
505 p_input->i_id = ++priv->i_last_input_id;
506 vlc_object_unlock( p_obj->p_libvlc );
508 p_input->b_fixed_name = false;
511 p_input->psz_uri = strdup( psz_uri );
513 p_input->psz_uri = NULL;
515 p_input->i_type = i_type;
516 p_input->b_prefers_tree = false;
518 if( p_input->i_type == ITEM_TYPE_UNKNOWN )
519 GuessType( p_input );
521 if( psz_name != NULL )
522 p_input->psz_name = strdup( psz_name );
523 else if( p_input->i_type == ITEM_TYPE_FILE && p_input->psz_uri )
525 const char *psz_filename = strrchr( p_input->psz_uri, DIR_SEP_CHAR );
526 if( psz_filename && *psz_filename == DIR_SEP_CHAR )
528 p_input->psz_name = strdup( psz_filename && *psz_filename
529 ? psz_filename : p_input->psz_uri );
532 p_input->psz_name = p_input->psz_uri ? strdup( p_input->psz_uri ) : NULL;
534 p_input->i_duration = i_duration;
536 for( int i = 0; i < i_options; i++ )
537 input_item_AddOption( p_input, ppsz_options[i] );
541 /* Guess the type of the item using the beginning of the mrl */
542 static void GuessType( input_item_t *p_item)
545 static struct { const char *psz_search; int i_type; } types_array[] =
547 { "http", ITEM_TYPE_NET },
548 { "dvd", ITEM_TYPE_DISC },
549 { "cdda", ITEM_TYPE_CDDA },
550 { "mms", ITEM_TYPE_NET },
551 { "rtsp", ITEM_TYPE_NET },
552 { "udp", ITEM_TYPE_NET },
553 { "rtp", ITEM_TYPE_NET },
554 { "vcd", ITEM_TYPE_DISC },
555 { "v4l", ITEM_TYPE_CARD },
556 { "dshow", ITEM_TYPE_CARD },
557 { "pvr", ITEM_TYPE_CARD },
558 { "dvb", ITEM_TYPE_CARD },
559 { "qpsk", ITEM_TYPE_CARD },
560 { "sdp", ITEM_TYPE_NET },
564 if( !p_item->psz_uri )
566 p_item->i_type = ITEM_TYPE_FILE;
570 for( i = 0; types_array[i].psz_search != NULL; i++ )
572 if( !strncmp( p_item->psz_uri, types_array[i].psz_search,
573 strlen( types_array[i].psz_search ) ) )
575 p_item->i_type = types_array[i].i_type;
579 p_item->i_type = ITEM_TYPE_FILE;