git.sesse.net Git - vlc/blob - modules/demux/playlist/itml.c

   1 /*******************************************************************************
   2  * itml.c : iTunes Music Library import functions
   3  *******************************************************************************
   4  * Copyright (C) 2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Yoann Peronneau <yoann@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  * \file modules/demux/playlist/itml.c
  25  * \brief iTunes Music Library import functions
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_demux.h>
  34 #include <vlc_xml.h>
  35 #include <vlc_strings.h>
  36 #include <vlc_url.h>
  37
  38 #include "itml.h"
  39 #include "playlist.h"
  40
  41 struct demux_sys_t
  42 {
  43     int i_ntracks;
  44 };
  45
  46 static int Control( demux_t *, int, va_list );
  47 static int Demux( demux_t * );
  48
  49 /**
  50  * \brief iTML submodule initialization function
  51  */
  52 int Import_iTML( vlc_object_t *p_this )
  53 {
  54     DEMUX_BY_EXTENSION_OR_FORCED_MSG( ".xml", "itml",
  55                                       "using iTunes Media Library reader" );
  56     return VLC_SUCCESS;
  57 }
  58
  59 void Close_iTML( vlc_object_t *p_this )
  60 {
  61     demux_t *p_demux = (demux_t *)p_this;
  62     free( p_demux->p_sys );
  63 }
  64
  65 /**
  66  * \brief demuxer function for iTML parsing
  67  */
  68 int Demux( demux_t *p_demux )
  69 {
  70     xml_t *p_xml;
  71     xml_reader_t *p_xml_reader = NULL;
  72     char *psz_name = NULL;
  73
  74     input_item_t *p_current_input = GetCurrentItem(p_demux);
  75     p_demux->p_sys->i_ntracks = 0;
  76
  77     /* create new xml parser from stream */
  78     p_xml = xml_Create( p_demux );
  79     if( !p_xml )
  80         goto end;
  81
  82     p_xml_reader = xml_ReaderCreate( p_xml, p_demux->s );
  83     if( !p_xml_reader )
  84         goto end;
  85
  86     /* locating the root node */
  87     do
  88     {
  89         if( xml_ReaderRead( p_xml_reader ) != 1 )
  90         {
  91             msg_Err( p_demux, "can't read xml stream" );
  92             goto end;
  93         }
  94     } while( xml_ReaderNodeType( p_xml_reader ) != XML_READER_STARTELEM );
  95
  96     /* checking root node name */
  97     psz_name = xml_ReaderName( p_xml_reader );
  98     if( !psz_name || strcmp( psz_name, "plist" ) )
  99     {
 100         msg_Err( p_demux, "invalid root node name: %s", psz_name );
 101         goto end;
 102     }
 103
 104     xml_elem_hnd_t pl_elements[] =
 105         { {"dict",    COMPLEX_CONTENT, {.cmplx = parse_plist_dict} } };
 106     parse_plist_node( p_demux, p_current_input, NULL, p_xml_reader, "plist",
 107                       pl_elements );
 108
 109     vlc_gc_decref(p_current_input);
 110
 111 end:
 112     free( psz_name );
 113     if( p_xml_reader )
 114         xml_ReaderDelete( p_xml, p_xml_reader );
 115     if( p_xml )
 116         xml_Delete( p_xml );
 117
 118     /* Needed for correct operation of go back */
 119     return 0;
 120 }
 121
 122 /** \brief dummy function for demux callback interface */
 123 static int Control( demux_t *p_demux, int i_query, va_list args )
 124 {
 125     VLC_UNUSED(p_demux); VLC_UNUSED(i_query); VLC_UNUSED(args);
 126     return VLC_EGENERIC;
 127 }
 128
 129 /**
 130  * \brief parse the root node of the playlist
 131  */
 132 static bool parse_plist_node( demux_t *p_demux, input_item_t *p_input_item,
 133                               track_elem_t *p_track, xml_reader_t *p_xml_reader,
 134                               const char *psz_element,
 135                               xml_elem_hnd_t *p_handlers )
 136 {
 137     VLC_UNUSED(p_track); VLC_UNUSED(psz_element);
 138     char *psz_name;
 139     char *psz_value;
 140     bool b_version_found = false;
 141
 142     /* read all playlist attributes */
 143     while( xml_ReaderNextAttr( p_xml_reader ) == VLC_SUCCESS )
 144     {
 145         psz_name = xml_ReaderName( p_xml_reader );
 146         psz_value = xml_ReaderValue( p_xml_reader );
 147         if( !psz_name || !psz_value )
 148         {
 149             msg_Err( p_demux, "invalid xml stream @ <plist>" );
 150             free( psz_name );
 151             free( psz_value );
 152             return false;
 153         }
 154         /* attribute: version */
 155         if( !strcmp( psz_name, "version" ) )
 156         {
 157             b_version_found = true;
 158             if( strcmp( psz_value, "1.0" ) )
 159                 msg_Warn( p_demux, "unsupported iTunes Media Library version" );
 160         }
 161         /* unknown attribute */
 162         else
 163             msg_Warn( p_demux, "invalid <plist> attribute:\"%s\"", psz_name);
 164
 165         free( psz_name );
 166         free( psz_value );
 167     }
 168
 169     /* attribute version is mandatory !!! */
 170     if( !b_version_found )
 171         msg_Warn( p_demux, "<plist> requires \"version\" attribute" );
 172
 173     return parse_dict( p_demux, p_input_item, NULL, p_xml_reader,
 174                        "plist", p_handlers );
 175 }
 176
 177 /**
 178  * \brief parse a <dict>
 179  * \param COMPLEX_INTERFACE
 180  */
 181 static bool parse_dict( demux_t *p_demux, input_item_t *p_input_item,
 182                         track_elem_t *p_track, xml_reader_t *p_xml_reader,
 183                         const char *psz_element, xml_elem_hnd_t *p_handlers )
 184 {
 185     int i_node;
 186     char *psz_name = NULL;
 187     char *psz_value = NULL;
 188     char *psz_key = NULL;
 189     xml_elem_hnd_t *p_handler = NULL;
 190     bool b_ret = false;
 191
 192     while( xml_ReaderRead( p_xml_reader ) == 1 )
 193     {
 194         i_node = xml_ReaderNodeType( p_xml_reader );
 195         switch( i_node )
 196         {
 197         case XML_READER_NONE:
 198             break;
 199
 200         case XML_READER_STARTELEM:
 201             /*  element start tag  */
 202             psz_name = xml_ReaderName( p_xml_reader );
 203             if( !psz_name || !*psz_name )
 204             {
 205                 msg_Err( p_demux, "invalid xml stream" );
 206                 goto end;
 207             }
 208             /* choose handler */
 209             for( p_handler = p_handlers;
 210                      p_handler->name && strcmp( psz_name, p_handler->name );
 211                      p_handler++ );
 212             if( !p_handler->name )
 213             {
 214                 msg_Err( p_demux, "unexpected element <%s>", psz_name );
 215                 goto end;
 216             }
 217             FREE_NAME();
 218             /* complex content is parsed in a separate function */
 219             if( p_handler->type == COMPLEX_CONTENT )
 220             {
 221                 if( p_handler->pf_handler.cmplx( p_demux, p_input_item, NULL,
 222                                                  p_xml_reader, p_handler->name,
 223                                                  NULL ) )
 224                 {
 225                     p_handler = NULL;
 226                     FREE_ATT_KEY();
 227                 }
 228                 else
 229                     goto end;
 230             }
 231             break;
 232
 233         case XML_READER_TEXT:
 234             /* simple element content */
 235             free( psz_value );
 236             psz_value = xml_ReaderValue( p_xml_reader );
 237             if( !psz_value )
 238             {
 239                 msg_Err( p_demux, "invalid xml stream" );
 240                 goto end;
 241             }
 242             break;
 243
 244         case XML_READER_ENDELEM:
 245             /* element end tag */
 246             psz_name = xml_ReaderName( p_xml_reader );
 247             if( !psz_name )
 248             {
 249                 msg_Err( p_demux, "invalid xml stream" );
 250                 goto end;
 251             }
 252             /* leave if the current parent node <track> is terminated */
 253             if( !strcmp( psz_name, psz_element ) )
 254             {
 255                 b_ret = true;
 256                 goto end;
 257             }
 258             /* there MUST have been a start tag for that element name */
 259             if( !p_handler || !p_handler->name
 260                 || strcmp( p_handler->name, psz_name ) )
 261             {
 262                 msg_Err( p_demux, "there's no open element left for <%s>",
 263                          psz_name );
 264                 goto end;
 265             }
 266             /* special case: key */
 267             if( !strcmp( p_handler->name, "key" ) )
 268             {
 269                 free( psz_key );
 270                 psz_key = strdup( psz_value );
 271             }
 272             /* call the simple handler */
 273             else if( p_handler->pf_handler.smpl )
 274             {
 275                 p_handler->pf_handler.smpl( p_track, psz_key, psz_value );
 276             }
 277             FREE_ATT();
 278             p_handler = NULL;
 279             break;
 280
 281         default:
 282             /* unknown/unexpected xml node */
 283             msg_Err( p_demux, "unexpected xml node %i", i_node );
 284             goto end;
 285         }
 286         FREE_NAME();
 287     }
 288     msg_Err( p_demux, "unexpected end of xml data" );
 289
 290 end:
 291     free( psz_name );
 292     free( psz_value );
 293     free( psz_key );
 294     return b_ret;
 295 }
 296
 297 static bool parse_plist_dict( demux_t *p_demux, input_item_t *p_input_item,
 298                               track_elem_t *p_track, xml_reader_t *p_xml_reader,
 299                               const char *psz_element,
 300                               xml_elem_hnd_t *p_handlers )
 301 {
 302     VLC_UNUSED(p_track); VLC_UNUSED(psz_element); VLC_UNUSED(p_handlers);
 303     xml_elem_hnd_t pl_elements[] =
 304         { {"dict",    COMPLEX_CONTENT, {.cmplx = parse_tracks_dict} },
 305           {"array",   SIMPLE_CONTENT,  {NULL} },
 306           {"key",     SIMPLE_CONTENT,  {NULL} },
 307           {"integer", SIMPLE_CONTENT,  {NULL} },
 308           {"string",  SIMPLE_CONTENT,  {NULL} },
 309           {"date",    SIMPLE_CONTENT,  {NULL} },
 310           {"true",    SIMPLE_CONTENT,  {NULL} },
 311           {"false",   SIMPLE_CONTENT,  {NULL} },
 312           {NULL,      UNKNOWN_CONTENT, {NULL} }
 313         };
 314
 315     return parse_dict( p_demux, p_input_item, NULL, p_xml_reader,
 316                        "dict", pl_elements );
 317 }
 318
 319 static bool parse_tracks_dict( demux_t *p_demux, input_item_t *p_input_item,
 320                                track_elem_t *p_track, xml_reader_t *p_xml_reader,
 321                                const char *psz_element,
 322                                xml_elem_hnd_t *p_handlers )
 323 {
 324     VLC_UNUSED(p_track); VLC_UNUSED(psz_element); VLC_UNUSED(p_handlers);
 325     xml_elem_hnd_t tracks_elements[] =
 326         { {"dict",    COMPLEX_CONTENT, {.cmplx = parse_track_dict} },
 327           {"key",     SIMPLE_CONTENT,  {NULL} },
 328           {NULL,      UNKNOWN_CONTENT, {NULL} }
 329         };
 330
 331     parse_dict( p_demux, p_input_item, NULL, p_xml_reader,
 332                 "dict", tracks_elements );
 333
 334     msg_Info( p_demux, "added %i tracks successfully",
 335               p_demux->p_sys->i_ntracks );
 336
 337     return true;
 338 }
 339
 340 static bool parse_track_dict( demux_t *p_demux, input_item_t *p_input_item,
 341                               track_elem_t *p_track, xml_reader_t *p_xml_reader,
 342                               const char *psz_element,
 343                               xml_elem_hnd_t *p_handlers )
 344 {
 345     VLC_UNUSED(psz_element); VLC_UNUSED(p_handlers);
 346     input_item_t *p_new_input = NULL;
 347     int i_ret;
 348     char *psz_uri = NULL;
 349     p_track = new_track();
 350
 351     xml_elem_hnd_t track_elements[] =
 352         { {"array",   COMPLEX_CONTENT, {.cmplx = skip_element} },
 353           {"key",     SIMPLE_CONTENT,  {.smpl = save_data} },
 354           {"integer", SIMPLE_CONTENT,  {.smpl = save_data} },
 355           {"string",  SIMPLE_CONTENT,  {.smpl = save_data} },
 356           {"date",    SIMPLE_CONTENT,  {.smpl = save_data} },
 357           {"true",    SIMPLE_CONTENT,  {NULL} },
 358           {"false",   SIMPLE_CONTENT,  {NULL} },
 359           {NULL,      UNKNOWN_CONTENT, {NULL} }
 360         };
 361
 362     i_ret = parse_dict( p_demux, p_input_item, p_track,
 363                         p_xml_reader, "dict", track_elements );
 364
 365     msg_Dbg( p_demux, "name: %s, artist: %s, album: %s, genre: %s, trackNum: %s, location: %s",
 366              p_track->name, p_track->artist, p_track->album, p_track->genre, p_track->trackNum, p_track->location );
 367
 368     if( !p_track->location )
 369     {
 370         msg_Err( p_demux, "Track needs Location" );
 371         free_track( p_track );
 372         return false;
 373     }
 374
 375     psz_uri = decode_URI_duplicate( p_track->location );
 376
 377     if( psz_uri )
 378     {
 379         msg_Info( p_demux, "Adding '%s'", psz_uri );
 380
 381         p_new_input = input_item_New( p_demux, psz_uri, NULL );
 382         input_item_AddSubItem( p_input_item, p_new_input );
 383
 384         /* add meta info */
 385         add_meta( p_new_input, p_track );
 386         vlc_gc_decref( p_new_input );
 387
 388         p_demux->p_sys->i_ntracks++;
 389         free( psz_uri );
 390     }
 391
 392     free_track( p_track );
 393     return i_ret;
 394 }
 395
 396 static track_elem_t *new_track()
 397 {
 398     track_elem_t *p_track;
 399     p_track = malloc( sizeof( track_elem_t ) );
 400     if( p_track )
 401     {
 402         p_track->name = NULL;
 403         p_track->artist = NULL;
 404         p_track->album = NULL;
 405         p_track->genre = NULL;
 406         p_track->trackNum = NULL;
 407         p_track->location = NULL;
 408         p_track->duration = 0;
 409     }
 410     return p_track;
 411 }
 412
 413 static void free_track( track_elem_t *p_track )
 414 {
 415     fprintf( stderr, "free track\n" );
 416     if ( !p_track )
 417         return;
 418
 419     FREENULL( p_track->name );
 420     FREENULL( p_track->artist );
 421     FREENULL( p_track->album );
 422     FREENULL( p_track->genre );
 423     FREENULL( p_track->trackNum );
 424     FREENULL( p_track->location );
 425     p_track->duration = 0;
 426     free( p_track );
 427 }
 428
 429 static bool save_data( track_elem_t *p_track, const char *psz_name,
 430                        char *psz_value)
 431 {
 432     /* exit if setting is impossible */
 433     if( !psz_name || !psz_value || !p_track )
 434         return false;
 435
 436     /* re-convert xml special characters inside psz_value */
 437     resolve_xml_special_chars( psz_value );
 438
 439 #define SAVE_INFO( name, value ) \
 440     if( !strcmp( psz_name, name ) ) { p_track->value = strdup( psz_value ); }
 441
 442     SAVE_INFO( "Name", name )
 443     else SAVE_INFO( "Artist", artist )
 444     else SAVE_INFO( "Album", album )
 445     else SAVE_INFO( "Genre", genre )
 446     else SAVE_INFO( "Track Number", trackNum )
 447     else SAVE_INFO( "Location", location )
 448     else if( !strcmp( psz_name, "Total Time" ) )
 449     {
 450         long i_num = atol( psz_value );
 451         p_track->duration = (mtime_t) i_num*1000;
 452     }
 453 #undef SAVE_INFO
 454     return true;
 455 }
 456
 457 /**
 458  * \brief handles the supported <track> sub-elements
 459  */
 460 static bool add_meta( input_item_t *p_input_item, track_elem_t *p_track )
 461 {
 462     /* exit if setting is impossible */
 463     if( !p_input_item || !p_track )
 464         return false;
 465
 466 #define SET_INFO( type, prop ) \
 467     if( p_track->prop ) {input_item_Set##type( p_input_item, p_track->prop );}
 468     SET_INFO( Title, name )
 469     SET_INFO( Artist, artist )
 470     SET_INFO( Album, album )
 471     SET_INFO( Genre, genre )
 472     SET_INFO( TrackNum, trackNum )
 473     SET_INFO( Duration, duration )
 474 #undef SET_INFO
 475     return true;
 476 }
 477
 478 /**
 479  * \brief skips complex element content that we can't manage
 480  */
 481 static bool skip_element( demux_t *p_demux, input_item_t *p_input_item,
 482                           track_elem_t *p_track, xml_reader_t *p_xml_reader,
 483                           const char *psz_element, xml_elem_hnd_t *p_handlers )
 484 {
 485     VLC_UNUSED(p_demux); VLC_UNUSED(p_input_item);
 486     VLC_UNUSED(p_track); VLC_UNUSED(p_handlers);
 487     char *psz_endname;
 488
 489     while( xml_ReaderRead( p_xml_reader ) == 1 )
 490     {
 491         if( xml_ReaderNodeType( p_xml_reader ) == XML_READER_ENDELEM )
 492         {
 493             psz_endname = xml_ReaderName( p_xml_reader );
 494             if( !psz_endname )
 495                 return false;
 496             if( !strcmp( psz_element, psz_endname ) )
 497             {
 498                 free( psz_endname );
 499                 return true;
 500             }
 501             else
 502                 free( psz_endname );
 503         }
 504     }
 505     return false;
 506 }