Contribs: update mpg123 to 1.25.10
[vlc.git] / lib / media_discoverer.c
blobb0004ffb1f474d4705efab573afd0725c2d8668c
1 /*****************************************************************************
2 * media_discoverer.c: libvlc new API media discoverer functions
3 *****************************************************************************
4 * Copyright (C) 2007 VLC authors and VideoLAN
5 * $Id$
7 * Authors: Pierre d'Herbemont <pdherbemont # videolan.org>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Lesser General Public License as published by
11 * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
28 #include <assert.h>
30 #include <vlc/libvlc.h>
31 #include <vlc/libvlc_media.h>
32 #include <vlc/libvlc_media_list.h>
33 #include <vlc/libvlc_media_discoverer.h>
34 #include <vlc/libvlc_events.h>
36 #include <vlc_services_discovery.h>
38 #include "libvlc_internal.h"
39 #include "media_internal.h" // libvlc_media_new_from_input_item()
40 #include "media_list_internal.h" // libvlc_media_list_internal_add_media()
42 struct libvlc_media_discoverer_t
44 libvlc_instance_t * p_libvlc_instance;
45 services_discovery_t * p_sd;
46 libvlc_media_list_t * p_mlist;
47 vlc_dictionary_t catname_to_submedialist;
48 char name[];
52 * Private functions
55 /**************************************************************************
56 * services_discovery_item_added (Private) (VLC event callback)
57 **************************************************************************/
59 static void services_discovery_item_added( services_discovery_t *sd,
60 input_item_t *parent,
61 input_item_t *p_item,
62 const char *psz_cat )
64 libvlc_media_t * p_md;
65 libvlc_media_discoverer_t *p_mdis = sd->owner.sys;
66 libvlc_media_list_t * p_mlist = p_mdis->p_mlist;
68 p_md = libvlc_media_new_from_input_item( p_mdis->p_libvlc_instance,
69 p_item );
71 if( parent != NULL )
73 /* Flatten items list for now. TODO: tree support. */
75 else
76 /* If we have a category, that mean we have to group the items having
77 * that category in a media_list. */
78 if( psz_cat )
80 p_mlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, psz_cat );
82 if( p_mlist == kVLCDictionaryNotFound )
84 libvlc_media_t * p_catmd;
85 p_catmd = libvlc_media_new_as_node( p_mdis->p_libvlc_instance, psz_cat );
86 p_mlist = libvlc_media_subitems( p_catmd );
87 p_mlist->b_read_only = true;
89 /* Insert the newly created mlist in our dictionary */
90 vlc_dictionary_insert( &p_mdis->catname_to_submedialist, psz_cat, p_mlist );
92 /* Insert the md into the root list */
93 libvlc_media_list_lock( p_mdis->p_mlist );
94 libvlc_media_list_internal_add_media( p_mdis->p_mlist, p_catmd );
95 libvlc_media_list_unlock( p_mdis->p_mlist );
97 /* We don't release the mlist cause the dictionary
98 * doesn't retain the object. But we release the md. */
99 libvlc_media_release( p_catmd );
103 libvlc_media_list_lock( p_mlist );
104 libvlc_media_list_internal_add_media( p_mlist, p_md );
105 libvlc_media_list_unlock( p_mlist );
107 libvlc_media_release( p_md );
110 /**************************************************************************
111 * services_discovery_item_removed (Private) (VLC event callback)
112 **************************************************************************/
114 static void services_discovery_item_removed( services_discovery_t *sd,
115 input_item_t *p_item )
117 libvlc_media_t * p_md;
118 libvlc_media_discoverer_t *p_mdis = sd->owner.sys;
120 int i, count = libvlc_media_list_count( p_mdis->p_mlist );
121 libvlc_media_list_lock( p_mdis->p_mlist );
122 for( i = 0; i < count; i++ )
124 p_md = libvlc_media_list_item_at_index( p_mdis->p_mlist, i );
125 assert(p_md != NULL);
126 if( p_md->p_input_item == p_item )
128 libvlc_media_list_internal_remove_index( p_mdis->p_mlist, i );
129 libvlc_media_release( p_md );
130 break;
132 libvlc_media_release( p_md );
134 libvlc_media_list_unlock( p_mdis->p_mlist );
138 * Public libvlc functions
141 /**************************************************************************
142 * new (Public)
143 **************************************************************************/
144 libvlc_media_discoverer_t *
145 libvlc_media_discoverer_new( libvlc_instance_t * p_inst, const char * psz_name )
147 /* podcast SD is a hack and only works with custom playlist callbacks. */
148 if( !strncasecmp( psz_name, "podcast", 7 ) )
149 return NULL;
151 libvlc_media_discoverer_t *p_mdis;
153 p_mdis = malloc(sizeof(*p_mdis) + strlen(psz_name) + 1);
154 if( unlikely(p_mdis == NULL) )
156 libvlc_printerr( "Not enough memory" );
157 return NULL;
160 p_mdis->p_libvlc_instance = p_inst;
161 p_mdis->p_mlist = libvlc_media_list_new( p_inst );
162 p_mdis->p_mlist->b_read_only = true;
163 p_mdis->p_sd = NULL;
165 vlc_dictionary_init( &p_mdis->catname_to_submedialist, 0 );
167 libvlc_retain( p_inst );
168 strcpy( p_mdis->name, psz_name );
169 return p_mdis;
172 /**************************************************************************
173 * start (Public)
174 **************************************************************************/
175 LIBVLC_API int
176 libvlc_media_discoverer_start( libvlc_media_discoverer_t * p_mdis )
178 struct services_discovery_owner_t owner = {
179 p_mdis,
180 services_discovery_item_added,
181 services_discovery_item_removed,
184 /* Here we go */
185 p_mdis->p_sd = vlc_sd_Create( (vlc_object_t *)p_mdis->p_libvlc_instance->p_libvlc_int,
186 p_mdis->name, &owner );
187 if( p_mdis->p_sd == NULL )
189 libvlc_printerr( "%s: no such discovery module found", p_mdis->name );
190 return -1;
193 return 0;
196 /**************************************************************************
197 * stop (Public)
198 **************************************************************************/
199 LIBVLC_API void
200 libvlc_media_discoverer_stop( libvlc_media_discoverer_t * p_mdis )
202 libvlc_media_list_t * p_mlist = p_mdis->p_mlist;
203 libvlc_media_list_lock( p_mlist );
204 libvlc_media_list_internal_end_reached( p_mlist );
205 libvlc_media_list_unlock( p_mlist );
207 vlc_sd_Destroy( p_mdis->p_sd );
208 p_mdis->p_sd = NULL;
211 /**************************************************************************
212 * release (Public)
213 **************************************************************************/
214 static void
215 MediaListDictValueRelease( void* mlist, void* obj )
217 libvlc_media_list_release( mlist );
218 (void)obj;
221 void
222 libvlc_media_discoverer_release( libvlc_media_discoverer_t * p_mdis )
224 if( p_mdis->p_sd != NULL )
225 libvlc_media_discoverer_stop( p_mdis );
227 libvlc_media_list_release( p_mdis->p_mlist );
229 vlc_dictionary_clear( &p_mdis->catname_to_submedialist,
230 MediaListDictValueRelease, NULL );
232 libvlc_release( p_mdis->p_libvlc_instance );
234 free( p_mdis );
237 /**************************************************************************
238 * media_list (Public)
239 **************************************************************************/
240 libvlc_media_list_t *
241 libvlc_media_discoverer_media_list( libvlc_media_discoverer_t * p_mdis )
243 libvlc_media_list_retain( p_mdis->p_mlist );
244 return p_mdis->p_mlist;
247 /**************************************************************************
248 * running (Public)
249 **************************************************************************/
251 libvlc_media_discoverer_is_running( libvlc_media_discoverer_t * p_mdis )
253 return p_mdis->p_sd != NULL;
256 void
257 libvlc_media_discoverer_list_release( libvlc_media_discoverer_description_t **pp_services,
258 size_t i_count )
260 if( i_count > 0 )
262 for( size_t i = 0; i < i_count; ++i )
264 free( pp_services[i]->psz_name );
265 free( pp_services[i]->psz_longname );
267 free( *pp_services );
268 free( pp_services );
272 size_t
273 libvlc_media_discoverer_list_get( libvlc_instance_t *p_inst,
274 libvlc_media_discoverer_category_t i_cat,
275 libvlc_media_discoverer_description_t ***ppp_services )
277 assert( p_inst != NULL && ppp_services != NULL );
279 int i_core_cat;
280 switch( i_cat )
282 case libvlc_media_discoverer_devices:
283 i_core_cat = SD_CAT_DEVICES;
284 break;
285 case libvlc_media_discoverer_lan:
286 i_core_cat = SD_CAT_LAN;
287 break;
288 case libvlc_media_discoverer_podcasts:
289 i_core_cat = SD_CAT_INTERNET;
290 break;
291 case libvlc_media_discoverer_localdirs:
292 i_core_cat = SD_CAT_MYCOMPUTER;
293 break;
294 default:
295 vlc_assert_unreachable();
296 *ppp_services = NULL;
297 return 0;
300 /* Fetch all sd names, longnames and categories */
301 char **ppsz_names, **ppsz_longnames;
302 int *p_categories;
303 ppsz_names = vlc_sd_GetNames( p_inst->p_libvlc_int, &ppsz_longnames,
304 &p_categories );
306 if( ppsz_names == NULL )
308 *ppp_services = NULL;
309 return 0;
312 /* Count the number of sd matching our category (i_cat/i_core_cat) */
313 size_t i_nb_services = 0;
314 char **ppsz_name = ppsz_names;
315 int *p_category = p_categories;
316 for( ; *ppsz_name != NULL; ppsz_name++, p_category++ )
318 if( *p_category == i_core_cat )
319 i_nb_services++;
322 libvlc_media_discoverer_description_t **pp_services = NULL, *p_services = NULL;
323 if( i_nb_services > 0 )
325 /* Double alloc here, so that the caller iterates through pointers of
326 * struct instead of structs. This allows us to modify the struct
327 * without breaking the API. */
329 pp_services = malloc( i_nb_services
330 * sizeof(libvlc_media_discoverer_description_t *) );
331 p_services = malloc( i_nb_services
332 * sizeof(libvlc_media_discoverer_description_t) );
333 if( pp_services == NULL || p_services == NULL )
335 free( pp_services );
336 free( p_services );
337 pp_services = NULL;
338 p_services = NULL;
339 i_nb_services = 0;
340 /* Even if alloc fails, the next loop must be run in order to free
341 * names returned by vlc_sd_GetNames */
345 /* Fill output pp_services or free unused name, longname */
346 char **ppsz_longname = ppsz_longnames;
347 ppsz_name = ppsz_names;
348 p_category = p_categories;
349 unsigned int i_service_idx = 0;
350 libvlc_media_discoverer_description_t *p_service = p_services;
351 for( ; *ppsz_name != NULL; ppsz_name++, ppsz_longname++, p_category++ )
353 if( pp_services != NULL && *p_category == i_core_cat )
355 p_service->psz_name = *ppsz_name;
356 p_service->psz_longname = *ppsz_longname;
357 p_service->i_cat = i_cat;
358 pp_services[i_service_idx++] = p_service++;
360 else
362 free( *ppsz_name );
363 free( *ppsz_longname );
366 free( ppsz_names );
367 free( ppsz_longnames );
368 free( p_categories );
370 *ppp_services = pp_services;
371 return i_nb_services;