Remove unused option: b_prefers_tree
[vlc.git] / 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/vlc.h>
30 #include "vlc_playlist.h"
31 #include "vlc_interface.h"
32
33 #include "input_internal.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_ItemInit( vlc_object_t *p_o, input_item_t *p_i )
40 {
41     memset( p_i, 0, sizeof(input_item_t) );
42     p_i->psz_name = NULL;
43     p_i->psz_uri = NULL;
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 );
48
49     p_i->i_type = ITEM_TYPE_UNKNOWN;
50     p_i->b_fixed_name = true;
51
52     p_i->p_stats = NULL;
53     p_i->p_meta = NULL;
54
55     vlc_mutex_init( p_o, &p_i->lock );
56     vlc_event_manager_init( &p_i->event_manager, p_i, p_o );
57     vlc_event_manager_register_event_type( &p_i->event_manager,
58         vlc_InputItemMetaChanged );
59     vlc_event_manager_register_event_type( &p_i->event_manager,
60         vlc_InputItemSubItemAdded );
61     vlc_event_manager_register_event_type( &p_i->event_manager,
62         vlc_InputItemDurationChanged );
63     vlc_event_manager_register_event_type( &p_i->event_manager,
64         vlc_InputItemPreparsedChanged );
65 }
66
67 static inline void input_ItemClean( input_item_t *p_i )
68 {
69     int i;
70
71     vlc_event_manager_fini( &p_i->event_manager );
72
73     free( p_i->psz_name );
74     free( p_i->psz_uri );
75     if( p_i->p_stats )
76     {
77         vlc_mutex_destroy( &p_i->p_stats->lock );
78         free( p_i->p_stats );
79     }
80
81     if( p_i->p_meta )
82         vlc_meta_Delete( p_i->p_meta );
83
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 );
87     free( p_i->optflagv);
88
89     for( i = 0; i < p_i->i_es; i++ )
90     {
91         es_format_Clean( p_i->es[i] );
92         free( p_i->es[i] );
93     }
94     TAB_CLEAN( p_i->i_es, p_i->es );
95
96     for( i = 0; i < p_i->i_categories; i++ )
97     {
98         info_category_t *p_category = p_i->pp_categories[i];
99         int j;
100
101         for( j = 0; j < p_category->i_infos; j++ )
102         {
103             struct info_t *p_info = p_category->pp_infos[j];
104
105             free( p_info->psz_name);
106             free( p_info->psz_value );
107             free( p_info );
108         }
109         TAB_CLEAN( p_category->i_infos, p_category->pp_infos );
110
111         free( p_category->psz_name );
112         free( p_category );
113     }
114     TAB_CLEAN( p_i->i_categories, p_i->pp_categories );
115
116     vlc_mutex_destroy( &p_i->lock );
117 }
118
119 void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val )
120 {
121     vlc_event_t event;
122
123     vlc_mutex_lock( &p_i->lock );
124     if( !p_i->p_meta )
125         p_i->p_meta = vlc_meta_New();
126     vlc_meta_Set( p_i->p_meta, meta_type, psz_val );
127     vlc_mutex_unlock( &p_i->lock );
128
129     /* Notify interested third parties */
130     event.type = vlc_InputItemMetaChanged;
131     event.u.input_item_meta_changed.meta_type = meta_type;
132     vlc_event_send( &p_i->event_manager, &event );
133 }
134
135 /**
136  * Get the item from an input thread
137  */
138 input_item_t *input_GetItem( input_thread_t *p_input )
139 {
140     assert( p_input && p_input->p );
141     return p_input->p->input.p_item;
142 }
143
144 /**
145  * Get a info item from a given category in a given input item.
146  *
147  * \param p_i The input item to get info from
148  * \param psz_cat String representing the category for the info
149  * \param psz_name String representing the name of the desired info
150  * \return A pointer to the string with the given info if found, or an
151  *         empty string otherwise. The caller should free the returned
152  *         pointer.
153  */
154 char *input_ItemGetInfo( input_item_t *p_i,
155                               const char *psz_cat,
156                               const char *psz_name )
157 {
158     int i,j;
159
160     vlc_mutex_lock( &p_i->lock );
161
162     for( i = 0 ; i< p_i->i_categories  ; i++ )
163     {
164         info_category_t *p_cat = p_i->pp_categories[i];
165
166         if( !psz_cat || strcmp( p_cat->psz_name, psz_cat ) )
167             continue;
168
169         for( j = 0; j < p_cat->i_infos ; j++ )
170         {
171             if( !strcmp( p_cat->pp_infos[j]->psz_name, psz_name ) )
172             {
173                 char *psz_ret = strdup( p_cat->pp_infos[j]->psz_value );
174                 vlc_mutex_unlock( &p_i->lock );
175                 return psz_ret;
176             }
177         }
178     }
179     vlc_mutex_unlock( &p_i->lock );
180     return strdup( "" );
181 }
182
183 static void input_ItemDestroy ( gc_object_t *p_this )
184 {
185     vlc_object_t *p_obj = (vlc_object_t *)p_this->p_destructor_arg;
186     input_item_t *p_input = (input_item_t *) p_this;
187     int i;
188
189     input_ItemClean( p_input );
190
191     vlc_mutex_lock( &p_obj->p_libvlc->object_lock );
192
193     ARRAY_BSEARCH( p_obj->p_libvlc->input_items,->i_id, int, p_input->i_id, i);
194     if( i != -1 )
195         ARRAY_REMOVE( p_obj->p_libvlc->input_items, i);
196
197     vlc_mutex_unlock( &p_obj->p_libvlc->object_lock );
198
199     free( p_input );
200 }
201
202 int input_ItemAddOpt( input_item_t *p_input, const char *psz_option,
203                       unsigned flags )
204 {
205     int err = VLC_SUCCESS;
206
207     if( psz_option == NULL )
208         return VLC_EGENERIC;
209
210     vlc_mutex_lock( &p_input->lock );
211     if (flags & VLC_INPUT_OPTION_UNIQUE)
212     {
213         for (int i = 0 ; i < p_input->i_options; i++)
214             if( !strcmp( p_input->ppsz_options[i], psz_option ) )
215                 goto out;
216     }
217
218     uint8_t *flagv = realloc (p_input->optflagv, p_input->optflagc + 1);
219     if (flagv == NULL)
220     {
221         err = VLC_ENOMEM;
222         goto out;
223     }
224     p_input->optflagv = flagv;
225     flagv[p_input->optflagc++] = flags;
226
227     INSERT_ELEM( p_input->ppsz_options, p_input->i_options,
228                  p_input->i_options, strdup( psz_option ) );
229 out:
230     vlc_mutex_unlock( &p_input->lock );
231     return err;
232 }
233
234 int input_ItemAddInfo( input_item_t *p_i,
235                             const char *psz_cat,
236                             const char *psz_name,
237                             const char *psz_format, ... )
238 {
239     va_list args;
240     int i;
241     info_t *p_info = NULL;
242     info_category_t *p_cat = NULL ;
243
244     vlc_mutex_lock( &p_i->lock );
245
246     for( i = 0 ; i < p_i->i_categories ; i ++ )
247     {
248         if( !strcmp( p_i->pp_categories[i]->psz_name, psz_cat ) )
249         {
250             p_cat = p_i->pp_categories[i];
251             break;
252         }
253     }
254     if( !p_cat )
255     {
256         if( !(p_cat = (info_category_t *)malloc( sizeof(info_category_t) )) )
257         {
258             vlc_mutex_unlock( &p_i->lock );
259             return VLC_ENOMEM;
260         }
261         p_cat->psz_name = strdup( psz_cat );
262         p_cat->i_infos = 0;
263         p_cat->pp_infos = 0;
264         INSERT_ELEM( p_i->pp_categories, p_i->i_categories, p_i->i_categories,
265                      p_cat );
266     }
267
268     for( i = 0; i< p_cat->i_infos; i++ )
269     {
270         if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
271         {
272             p_info = p_cat->pp_infos[i];
273             break;
274         }
275     }
276
277     if( !p_info )
278     {
279         if( ( p_info = (info_t *)malloc( sizeof( info_t ) ) ) == NULL )
280         {
281             vlc_mutex_unlock( &p_i->lock );
282             return VLC_ENOMEM;
283         }
284         INSERT_ELEM( p_cat->pp_infos, p_cat->i_infos, p_cat->i_infos, p_info );
285         p_info->psz_name = strdup( psz_name );
286     }
287     else
288     {
289         free( p_info->psz_value );
290     }
291
292     va_start( args, psz_format );
293     if( vasprintf( &p_info->psz_value, psz_format, args) )
294         p_info->psz_value = NULL;
295     va_end( args );
296
297     vlc_mutex_unlock( &p_i->lock );
298
299     return p_info->psz_value ? VLC_SUCCESS : VLC_ENOMEM;
300 }
301
302 input_item_t *__input_ItemGetById( vlc_object_t *p_obj, int i_id )
303 {
304     input_item_t * p_ret = NULL;
305     int i;
306
307     vlc_mutex_lock( &p_obj->p_libvlc->object_lock );
308
309     ARRAY_BSEARCH( p_obj->p_libvlc->input_items, ->i_id, int, i_id, i);
310     if( i != -1 )
311         p_ret = ARRAY_VAL( p_obj->p_libvlc->input_items, i);
312
313     vlc_mutex_unlock( &p_obj->p_libvlc->object_lock );
314
315     return p_ret;
316 }
317
318 input_item_t *__input_ItemNewExt( vlc_object_t *p_obj, const char *psz_uri,
319                                   const char *psz_name,
320                                   int i_options,
321                                   const char *const *ppsz_options,
322                                   mtime_t i_duration )
323 {
324     return input_ItemNewWithType( p_obj, psz_uri, psz_name,
325                                   i_options, ppsz_options,
326                                   i_duration, ITEM_TYPE_UNKNOWN );
327 }
328
329
330 input_item_t *input_ItemNewWithType( vlc_object_t *p_obj, const char *psz_uri,
331                                 const char *psz_name,
332                                 int i_options,
333                                 const char *const *ppsz_options,
334                                 mtime_t i_duration,
335                                 int i_type )
336 {
337     DECMALLOC_NULL( p_input, input_item_t );
338
339     input_ItemInit( p_obj, p_input );
340     vlc_gc_init( p_input, input_ItemDestroy, (void *)p_obj );
341
342     vlc_mutex_lock( &p_obj->p_libvlc->object_lock );
343     p_input->i_id = ++p_obj->p_libvlc->i_last_input_id;
344     ARRAY_APPEND( p_obj->p_libvlc->input_items, p_input );
345     vlc_mutex_unlock( &p_obj->p_libvlc->object_lock );
346
347     p_input->b_fixed_name = false;
348
349     if( psz_uri )
350         p_input->psz_uri = strdup( psz_uri );
351     else
352         p_input->psz_uri = NULL;
353
354     p_input->i_type = i_type;
355
356     if( p_input->i_type == ITEM_TYPE_UNKNOWN )
357         GuessType( p_input );
358
359     if( psz_name != NULL )
360         p_input->psz_name = strdup( psz_name );
361     else if( p_input->i_type == ITEM_TYPE_FILE && p_input->psz_uri )
362     {
363         const char *psz_filename = strrchr( p_input->psz_uri, DIR_SEP_CHAR );
364         if( psz_filename && *psz_filename == DIR_SEP_CHAR )
365             psz_filename++;
366         p_input->psz_name = strdup( psz_filename && *psz_filename
367                                     ? psz_filename : p_input->psz_uri );
368     }
369     else
370         p_input->psz_name = p_input->psz_uri ? strdup( p_input->psz_uri ) : NULL;
371
372     p_input->i_duration = i_duration;
373
374     for( int i = 0; i < i_options; i++ )
375         input_ItemAddOption( p_input, ppsz_options[i] );
376     return p_input;
377 }
378
379 /* Guess the type of the item using the beginning of the mrl */
380 static void GuessType( input_item_t *p_item)
381 {
382     int i;
383     static struct { const char *psz_search; int i_type; }  types_array[] =
384     {
385         { "http", ITEM_TYPE_NET },
386         { "dvd", ITEM_TYPE_DISC },
387         { "cdda", ITEM_TYPE_CDDA },
388         { "mms", ITEM_TYPE_NET },
389         { "rtsp", ITEM_TYPE_NET },
390         { "udp", ITEM_TYPE_NET },
391         { "rtp", ITEM_TYPE_NET },
392         { "vcd", ITEM_TYPE_DISC },
393         { "v4l", ITEM_TYPE_CARD },
394         { "dshow", ITEM_TYPE_CARD },
395         { "pvr", ITEM_TYPE_CARD },
396         { "dvb", ITEM_TYPE_CARD },
397         { "qpsk", ITEM_TYPE_CARD },
398         { "sdp", ITEM_TYPE_NET },
399         { NULL, 0 }
400     };
401
402     if( !p_item->psz_uri )
403     {
404         p_item->i_type = ITEM_TYPE_FILE;
405         return;
406     }
407
408     for( i = 0; types_array[i].psz_search != NULL; i++ )
409     {
410         if( !strncmp( p_item->psz_uri, types_array[i].psz_search,
411                       strlen( types_array[i].psz_search ) ) )
412         {
413             p_item->i_type = types_array[i].i_type;
414             return;
415         }
416     }
417     p_item->i_type = ITEM_TYPE_FILE;
418 }