lib/media_discoverer.c

   1 /*****************************************************************************
   2  * media_discoverer.c: libvlc new API media discoverer functions
   3  *****************************************************************************
   4  * Copyright (C) 2007 VLC authors and VideoLAN
   5  *
   6  * Authors: Pierre d'Herbemont <pdherbemont # videolan.org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #include <assert.h>
  28
  29 #include <vlc/libvlc.h>
  30 #include <vlc/libvlc_picture.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>
  35
  36 #include <vlc_services_discovery.h>
  37
  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()
  41
  42 struct libvlc_media_discoverer_t
  43 {
  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[];
  49 };
  50
  51 /*
  52  * Private functions
  53  */
  54
  55 /**************************************************************************
  56  *       services_discovery_item_added (Private) (VLC event callback)
  57  **************************************************************************/
  58
  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 )
  63 {
  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;
  67
  68     p_md = libvlc_media_new_from_input_item( p_mdis->p_libvlc_instance,
  69                                              p_item );
  70
  71     if( parent != NULL )
  72     {
  73         /* Flatten items list for now. TODO: tree support. */
  74     }
  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 )
  79     {
  80         p_mlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, psz_cat );
  81
  82         if( p_mlist == kVLCDictionaryNotFound )
  83         {
  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;
  88
  89             /* Insert the newly created mlist in our dictionary */
  90             vlc_dictionary_insert( &p_mdis->catname_to_submedialist, psz_cat, p_mlist );
  91
  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 );
  96
  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 );
 100         }
 101     }
 102
 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 );
 106
 107     libvlc_media_release( p_md );
 108 }
 109
 110 /**************************************************************************
 111  *       services_discovery_item_removed (Private) (VLC event callback)
 112  **************************************************************************/
 113
 114 static void services_discovery_item_removed( services_discovery_t *sd,
 115                                              input_item_t *p_item )
 116 {
 117     libvlc_media_t * p_md;
 118     libvlc_media_discoverer_t *p_mdis = sd->owner.sys;
 119
 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++ )
 123     {
 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 )
 127         {
 128             libvlc_media_list_internal_remove_index( p_mdis->p_mlist, i );
 129             libvlc_media_release( p_md );
 130             break;
 131         }
 132         libvlc_media_release( p_md );
 133     }
 134     libvlc_media_list_unlock( p_mdis->p_mlist );
 135 }
 136
 137 /*
 138  * Public libvlc functions
 139  */
 140
 141 /**************************************************************************
 142  *       new (Public)
 143  **************************************************************************/
 144 libvlc_media_discoverer_t *
 145 libvlc_media_discoverer_new( libvlc_instance_t * p_inst, const char * psz_name )
 146 {
 147     /* podcast SD is a hack and only works with custom playlist callbacks. */
 148     if( !strncasecmp( psz_name, "podcast", 7 ) )
 149         return NULL;
 150
 151     libvlc_media_discoverer_t *p_mdis;
 152
 153     p_mdis = malloc(sizeof(*p_mdis) + strlen(psz_name) + 1);
 154     if( unlikely(p_mdis == NULL) )
 155     {
 156         libvlc_printerr( "Not enough memory" );
 157         return NULL;
 158     }
 159
 160     p_mdis->p_libvlc_instance = p_inst;
 161     p_mdis->p_mlist = libvlc_media_list_new();
 162     p_mdis->p_mlist->b_read_only = true;
 163     p_mdis->p_sd = NULL;
 164
 165     vlc_dictionary_init( &p_mdis->catname_to_submedialist, 0 );
 166
 167     libvlc_retain( p_inst );
 168     strcpy( p_mdis->name, psz_name );
 169     return p_mdis;
 170 }
 171
 172 static const struct services_discovery_callbacks sd_cbs = {
 173     .item_added = services_discovery_item_added,
 174     .item_removed = services_discovery_item_removed,
 175 };
 176
 177 /**************************************************************************
 178  *       start (Public)
 179  **************************************************************************/
 180 LIBVLC_API int
 181 libvlc_media_discoverer_start( libvlc_media_discoverer_t * p_mdis )
 182 {
 183     struct services_discovery_owner_t owner = {
 184         &sd_cbs,
 185         p_mdis,
 186     };
 187
 188     /* Here we go */
 189     p_mdis->p_sd = vlc_sd_Create( (vlc_object_t *)p_mdis->p_libvlc_instance->p_libvlc_int,
 190                                   p_mdis->name, &owner );
 191     if( p_mdis->p_sd == NULL )
 192     {
 193         libvlc_printerr( "%s: no such discovery module found", p_mdis->name );
 194         return -1;
 195     }
 196
 197     return 0;
 198 }
 199
 200 /**************************************************************************
 201  *       stop (Public)
 202  **************************************************************************/
 203 LIBVLC_API void
 204 libvlc_media_discoverer_stop( libvlc_media_discoverer_t * p_mdis )
 205 {
 206     libvlc_media_list_t * p_mlist = p_mdis->p_mlist;
 207     libvlc_media_list_lock( p_mlist );
 208     libvlc_media_list_internal_end_reached( p_mlist );
 209     libvlc_media_list_unlock( p_mlist );
 210
 211     vlc_sd_Destroy( p_mdis->p_sd );
 212     p_mdis->p_sd = NULL;
 213 }
 214
 215 /**************************************************************************
 216  * release (Public)
 217  **************************************************************************/
 218 static void
 219 MediaListDictValueRelease( void* mlist, void* obj )
 220 {
 221     libvlc_media_list_release( mlist );
 222     (void)obj;
 223 }
 224
 225 void
 226 libvlc_media_discoverer_release( libvlc_media_discoverer_t * p_mdis )
 227 {
 228     if( p_mdis->p_sd != NULL )
 229         libvlc_media_discoverer_stop( p_mdis );
 230
 231     libvlc_media_list_release( p_mdis->p_mlist );
 232
 233     vlc_dictionary_clear( &p_mdis->catname_to_submedialist,
 234         MediaListDictValueRelease, NULL );
 235
 236     libvlc_release( p_mdis->p_libvlc_instance );
 237
 238     free( p_mdis );
 239 }
 240
 241 /**************************************************************************
 242  * media_list (Public)
 243  **************************************************************************/
 244 libvlc_media_list_t *
 245 libvlc_media_discoverer_media_list( libvlc_media_discoverer_t * p_mdis )
 246 {
 247     libvlc_media_list_retain( p_mdis->p_mlist );
 248     return p_mdis->p_mlist;
 249 }
 250
 251 /**************************************************************************
 252  * running (Public)
 253  **************************************************************************/
 254 bool libvlc_media_discoverer_is_running(libvlc_media_discoverer_t * p_mdis)
 255 {
 256     return p_mdis->p_sd != NULL;
 257 }
 258
 259 void
 260 libvlc_media_discoverer_list_release( libvlc_media_discoverer_description_t **pp_services,
 261                                       size_t i_count )
 262 {
 263     if( i_count > 0 )
 264     {
 265         for( size_t i = 0; i < i_count; ++i )
 266         {
 267             free( pp_services[i]->psz_name );
 268             free( pp_services[i]->psz_longname );
 269         }
 270         free( *pp_services );
 271         free( pp_services );
 272     }
 273 }
 274
 275 size_t
 276 libvlc_media_discoverer_list_get( libvlc_instance_t *p_inst,
 277                                   libvlc_media_discoverer_category_t i_cat,
 278                                   libvlc_media_discoverer_description_t ***ppp_services )
 279 {
 280     assert( p_inst != NULL && ppp_services != NULL );
 281
 282     int i_core_cat;
 283     switch( i_cat )
 284     {
 285     case libvlc_media_discoverer_devices:
 286         i_core_cat = SD_CAT_DEVICES;
 287         break;
 288     case libvlc_media_discoverer_lan:
 289         i_core_cat = SD_CAT_LAN;
 290         break;
 291     case libvlc_media_discoverer_podcasts:
 292         i_core_cat = SD_CAT_INTERNET;
 293         break;
 294     case libvlc_media_discoverer_localdirs:
 295         i_core_cat = SD_CAT_MYCOMPUTER;
 296         break;
 297     default:
 298         vlc_assert_unreachable();
 299         *ppp_services = NULL;
 300         return 0;
 301     }
 302
 303     /* Fetch all sd names, longnames and categories */
 304     char **ppsz_names, **ppsz_longnames;
 305     int *p_categories;
 306     ppsz_names = vlc_sd_GetNames( p_inst->p_libvlc_int, &ppsz_longnames,
 307                                   &p_categories );
 308
 309     if( ppsz_names == NULL )
 310     {
 311         *ppp_services = NULL;
 312         return 0;
 313     }
 314
 315     /* Count the number of sd matching our category (i_cat/i_core_cat) */
 316     size_t i_nb_services = 0;
 317     char **ppsz_name = ppsz_names;
 318     int *p_category = p_categories;
 319     for( ; *ppsz_name != NULL; ppsz_name++, p_category++ )
 320     {
 321         if( *p_category == i_core_cat )
 322             i_nb_services++;
 323     }
 324
 325     libvlc_media_discoverer_description_t **pp_services = NULL, *p_services = NULL;
 326     if( i_nb_services > 0 )
 327     {
 328         /* Double alloc here, so that the caller iterates through pointers of
 329          * struct instead of structs. This allows us to modify the struct
 330          * without breaking the API. */
 331
 332         pp_services = malloc( i_nb_services
 333                               * sizeof(libvlc_media_discoverer_description_t *) );
 334         p_services = malloc( i_nb_services
 335                              * sizeof(libvlc_media_discoverer_description_t) );
 336         if( pp_services == NULL || p_services == NULL )
 337         {
 338             free( pp_services );
 339             free( p_services );
 340             pp_services = NULL;
 341             p_services = NULL;
 342             i_nb_services = 0;
 343             /* Even if alloc fails, the next loop must be run in order to free
 344              * names returned by vlc_sd_GetNames */
 345         }
 346     }
 347
 348     /* Fill output pp_services or free unused name, longname */
 349     char **ppsz_longname = ppsz_longnames;
 350     ppsz_name = ppsz_names;
 351     p_category = p_categories;
 352     unsigned int i_service_idx = 0;
 353     libvlc_media_discoverer_description_t *p_service = p_services;
 354     for( ; *ppsz_name != NULL; ppsz_name++, ppsz_longname++, p_category++ )
 355     {
 356         if( pp_services != NULL && *p_category == i_core_cat )
 357         {
 358             p_service->psz_name = *ppsz_name;
 359             p_service->psz_longname = *ppsz_longname;
 360             p_service->i_cat = i_cat;
 361             pp_services[i_service_idx++] = p_service++;
 362         }
 363         else
 364         {
 365             free( *ppsz_name );
 366             free( *ppsz_longname );
 367         }
 368     }
 369     free( ppsz_names );
 370     free( ppsz_longnames );
 371     free( p_categories );
 372
 373     *ppp_services = pp_services;
 374     return i_nb_services;
 375 }