src/misc/medialibrary.c

   1 /*****************************************************************************
   2  * medialib.cpp: medialibrary module
   3  *****************************************************************************
   4  * Copyright © 2015-2016 VLC authors, VideoLAN and VideoLabs
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include <vlc_common.h>
  26 #include <vlc_media_library.h>
  27 #include <vlc_modules.h>
  28 #include <vlc_list.h>
  29 #include <vlc_threads.h>
  30 #include <libvlc.h>
  31
  32 #include <assert.h>
  33
  34 struct vlc_ml_event_callback_t
  35 {
  36     vlc_ml_callback_t pf_cb;
  37     void* p_data;
  38     struct vlc_list node;
  39 };
  40
  41 struct vlc_medialibrary_t
  42 {
  43     vlc_medialibrary_module_t m;
  44
  45     vlc_mutex_t lock;
  46     struct vlc_list cbs;
  47 };
  48
  49 static vlc_medialibrary_t* ml_priv( vlc_medialibrary_module_t* p_ml )
  50 {
  51     return container_of( p_ml, struct vlc_medialibrary_t, m );
  52 }
  53
  54 static void vlc_ml_event_send( vlc_medialibrary_module_t* p_ml, const vlc_ml_event_t* p_event )
  55 {
  56     vlc_medialibrary_t* p_priv = ml_priv( p_ml );
  57     vlc_mutex_lock( &p_priv->lock );
  58     struct vlc_ml_event_callback_t* p_cb;
  59     vlc_list_foreach( p_cb, &p_priv->cbs, node )
  60     {
  61         p_cb->pf_cb( p_cb->p_data, p_event );
  62     }
  63     vlc_mutex_unlock( &p_priv->lock );
  64 }
  65
  66 vlc_ml_event_callback_t*
  67 vlc_ml_event_register_callback( vlc_medialibrary_t* p_ml, vlc_ml_callback_t cb,
  68                                 void* p_data )
  69 {
  70     struct vlc_ml_event_callback_t* p_cb = malloc( sizeof( *p_cb ) );
  71     if ( unlikely( p_cb == NULL ) )
  72         return NULL;
  73     p_cb->pf_cb = cb;
  74     p_cb->p_data = p_data;
  75     vlc_mutex_lock( &p_ml->lock );
  76     vlc_list_append( &p_cb->node, &p_ml->cbs );
  77     vlc_mutex_unlock( &p_ml->lock );
  78     return p_cb;
  79 }
  80
  81 void vlc_ml_event_unregister_callback( vlc_medialibrary_t* p_ml,
  82                                        vlc_ml_event_callback_t* p_cb )
  83 {
  84     vlc_mutex_lock( &p_ml->lock );
  85     vlc_list_remove( &p_cb->node );
  86     vlc_mutex_unlock( &p_ml->lock );
  87     free( p_cb );
  88 }
  89
  90 void vlc_ml_event_unregister_from_callback( vlc_medialibrary_t* p_ml,
  91                                             vlc_ml_event_callback_t* p_cb )
  92 {
  93     vlc_mutex_assert( &p_ml->lock );
  94     vlc_list_remove( &p_cb->node );
  95     free( p_cb );
  96 }
  97
  98 static const vlc_medialibrary_callbacks_t callbacks = {
  99     .pf_send_event = &vlc_ml_event_send
 100 };
 101
 102 vlc_medialibrary_t* libvlc_MlCreate( libvlc_int_t* p_libvlc  )
 103 {
 104     vlc_medialibrary_t *p_ml = vlc_custom_create( VLC_OBJECT( p_libvlc ),
 105                                                   sizeof( *p_ml ), "medialibrary" );
 106     if ( unlikely( p_ml == NULL ) )
 107         return NULL;
 108     vlc_mutex_init( &p_ml->lock );
 109     vlc_list_init( &p_ml->cbs );
 110     p_ml->m.cbs = &callbacks;
 111     p_ml->m.p_module = module_need( &p_ml->m, "medialibrary", NULL, false );
 112     if ( p_ml->m.p_module == NULL )
 113     {
 114         vlc_mutex_destroy( &p_ml->lock );
 115         vlc_object_release( &p_ml->m );
 116         return NULL;
 117     }
 118     return p_ml;
 119 }
 120
 121 void libvlc_MlRelease( vlc_medialibrary_t* p_ml )
 122 {
 123     assert( p_ml != NULL );
 124     module_unneed( &p_ml->m, p_ml->m.p_module );
 125     assert( vlc_list_is_empty( &p_ml->cbs ) );
 126     vlc_mutex_destroy( &p_ml->lock );
 127     vlc_object_release( &p_ml->m );
 128 }
 129
 130 #undef vlc_ml_instance_get
 131 vlc_medialibrary_t* vlc_ml_instance_get( vlc_object_t* p_obj )
 132 {
 133     libvlc_priv_t* p_priv = libvlc_priv( p_obj->obj.libvlc );
 134     return p_priv->p_media_library;
 135 }
 136
 137 static void vlc_ml_show_release_inner( vlc_ml_show_t* p_show )
 138 {
 139     free( p_show->psz_artwork_mrl );
 140     free( p_show->psz_name );
 141     free( p_show->psz_summary );
 142     free( p_show->psz_tvdb_id );
 143 }
 144
 145 void vlc_ml_show_release( vlc_ml_show_t* p_show )
 146 {
 147     if ( p_show == NULL )
 148         return;
 149     vlc_ml_show_release_inner( p_show );
 150     free( p_show );
 151 }
 152
 153 static void vlc_ml_media_release_tracks_inner( vlc_ml_media_track_list_t* p_tracks )
 154 {
 155     if ( p_tracks == NULL )
 156         return;
 157     for ( size_t i = 0; i < p_tracks->i_nb_items; ++i )
 158     {
 159         vlc_ml_media_track_t* p_track = &p_tracks->p_items[i];
 160         free( p_track->psz_codec );
 161         free( p_track->psz_language );
 162         free( p_track->psz_description );
 163     }
 164     free( p_tracks );
 165 }
 166
 167 static void vlc_ml_media_release_inner( vlc_ml_media_t* p_media )
 168 {
 169     vlc_ml_file_list_release( p_media->p_files );
 170     vlc_ml_media_release_tracks_inner( p_media->p_tracks );
 171     free( p_media->psz_title );
 172     free( p_media->psz_artwork_mrl );
 173     switch( p_media->i_subtype )
 174     {
 175         case VLC_ML_MEDIA_SUBTYPE_ALBUMTRACK:
 176             break;
 177         case VLC_ML_MEDIA_SUBTYPE_SHOW_EPISODE:
 178             free( p_media->show_episode.psz_summary );
 179             free( p_media->show_episode.psz_tvdb_id );
 180             break;
 181         case VLC_ML_MEDIA_SUBTYPE_MOVIE:
 182             free( p_media->movie.psz_summary );
 183             free( p_media->movie.psz_imdb_id );
 184             break;
 185         default:
 186             break;
 187     }
 188 }
 189
 190 static void vlc_ml_artist_release_inner( vlc_ml_artist_t* p_artist )
 191 {
 192     free( p_artist->psz_artwork_mrl );
 193     free( p_artist->psz_name );
 194     free( p_artist->psz_shortbio );
 195     free( p_artist->psz_mb_id );
 196 }
 197
 198 void vlc_ml_artist_release( vlc_ml_artist_t* p_artist )
 199 {
 200     if ( p_artist == NULL )
 201         return;
 202     vlc_ml_artist_release_inner( p_artist );
 203     free( p_artist );
 204 }
 205
 206 static void vlc_ml_album_release_inner( vlc_ml_album_t* p_album )
 207 {
 208     free( p_album->psz_artist );
 209     free( p_album->psz_artwork_mrl );
 210     free( p_album->psz_summary );
 211     free( p_album->psz_title );
 212 }
 213
 214 void vlc_ml_album_release( vlc_ml_album_t* p_album )
 215 {
 216     if ( p_album == NULL )
 217         return;
 218     vlc_ml_album_release_inner( p_album );
 219     free( p_album );
 220 }
 221
 222 void vlc_ml_genre_release( vlc_ml_genre_t* p_genre )
 223 {
 224     if ( p_genre == NULL )
 225         return;
 226     free( p_genre->psz_name );
 227     free( p_genre );
 228 }
 229
 230 static void vlc_ml_playlist_release_inner( vlc_ml_playlist_t* p_playlist )
 231 {
 232     free( p_playlist->psz_artwork_mrl );
 233     free( p_playlist->psz_name );
 234 }
 235
 236 void vlc_ml_playlist_release( vlc_ml_playlist_t* p_playlist )
 237 {
 238     if ( p_playlist == NULL )
 239         return;
 240     vlc_ml_playlist_release_inner( p_playlist );
 241     free( p_playlist );
 242 }
 243
 244 /* Lists release */
 245
 246 void vlc_ml_media_release( vlc_ml_media_t* p_media )
 247 {
 248     if ( p_media == NULL )
 249         return;
 250     vlc_ml_media_release_inner( p_media );
 251     free( p_media );
 252 }
 253
 254 void vlc_ml_label_list_release( vlc_ml_label_list_t* p_list )
 255 {
 256     if ( p_list == NULL )
 257         return;
 258     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 259         free( p_list->p_items[i].psz_name );
 260     free( p_list );
 261 }
 262
 263 void vlc_ml_file_list_release( vlc_ml_file_list_t* p_list )
 264 {
 265     if ( p_list == NULL )
 266         return;
 267     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 268         free( p_list->p_items[i].psz_mrl );
 269     free( p_list );
 270 }
 271
 272 void vlc_ml_artist_list_release( vlc_ml_artist_list_t* p_list )
 273 {
 274     if ( p_list == NULL )
 275         return;
 276     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 277         vlc_ml_artist_release_inner( &p_list->p_items[i] );
 278     free( p_list );
 279 }
 280
 281
 282 void vlc_ml_media_list_release( vlc_ml_media_list_t* p_list )
 283 {
 284     if ( p_list == NULL )
 285         return;
 286     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 287         vlc_ml_media_release_inner( &p_list->p_items[i] );
 288     free( p_list );
 289 }
 290
 291 void vlc_ml_album_list_release( vlc_ml_album_list_t* p_list )
 292 {
 293     if ( p_list == NULL )
 294         return;
 295     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 296         vlc_ml_album_release_inner( &p_list->p_items[i] );
 297     free( p_list );
 298 }
 299
 300 void vlc_ml_show_list_release( vlc_ml_show_list_t* p_list )
 301 {
 302     if ( p_list == NULL )
 303         return;
 304     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 305         vlc_ml_show_release_inner( &p_list->p_items[i] );
 306     free( p_list );
 307 }
 308
 309 void vlc_ml_genre_list_release( vlc_ml_genre_list_t* p_list )
 310 {
 311     if ( p_list == NULL )
 312         return;
 313     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 314         free( p_list->p_items[i].psz_name );
 315     free( p_list );
 316 }
 317
 318 void vlc_ml_playlist_list_release( vlc_ml_playlist_list_t* p_list )
 319 {
 320     if ( p_list == NULL )
 321         return;
 322     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 323         vlc_ml_playlist_release_inner( &p_list->p_items[i] );
 324     free( p_list );
 325 }
 326
 327 void vlc_ml_entry_point_list_release( vlc_ml_entry_point_list_t* p_list )
 328 {
 329     if ( p_list == NULL )
 330         return;
 331     for ( size_t i = 0; i < p_list->i_nb_items; ++i )
 332         free( p_list->p_items[i].psz_mrl );
 333     free( p_list );
 334 }
 335
 336 void* vlc_ml_get( vlc_medialibrary_t* p_ml, int i_query, int64_t i_id )
 337 {
 338     assert( p_ml != NULL );
 339     return p_ml->m.pf_get( &p_ml->m, i_query, i_id );
 340 }
 341
 342 int vlc_ml_control( vlc_medialibrary_t* p_ml, int i_query, ... )
 343 {
 344     va_list args;
 345     va_start( args, i_query );
 346     int i_res = p_ml->m.pf_control( &p_ml->m, i_query, args );
 347     va_end( args );
 348     return i_res;
 349 }
 350
 351 int vlc_ml_list( vlc_medialibrary_t* p_ml, int i_query,
 352                              const vlc_ml_query_params_t* p_params, ... )
 353 {
 354     va_list args;
 355     va_start( args, p_params );
 356     int i_res = p_ml->m.pf_list( &p_ml->m, i_query, p_params, args );
 357     va_end( args );
 358     return i_res;
 359 }