podcast: implement image support (it might be a good idea to be able to set the
[vlc.git] / modules / demux / playlist / podcast.c
1 /*****************************************************************************
2  * podcast.c : podcast playlist imports
3  *****************************************************************************
4  * Copyright (C) 2005-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Antoine Cellerier <dionoea -at- videolan -dot- 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 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32 #include <vlc_demux.h>
33
34 #include "playlist.h"
35 #include <vlc_xml.h>
36
37 /*****************************************************************************
38  * Local prototypes
39  *****************************************************************************/
40 static int Demux( demux_t *p_demux);
41 static int Control( demux_t *p_demux, int i_query, va_list args );
42 static mtime_t strTimeToMTime( const char *psz );
43
44 /*****************************************************************************
45  * Import_podcast: main import function
46  *****************************************************************************/
47 int Import_podcast( vlc_object_t *p_this )
48 {
49     demux_t *p_demux = (demux_t *)p_this;
50
51     if( !demux_IsForced( p_demux, "podcast" ) )
52         return VLC_EGENERIC;
53
54     p_demux->pf_demux = Demux;
55     p_demux->pf_control = Control;
56     msg_Dbg( p_demux, "using podcast reader" );
57
58     return VLC_SUCCESS;
59 }
60
61 /*****************************************************************************
62  * Deactivate: frees unused data
63  *****************************************************************************/
64 void Close_podcast( vlc_object_t *p_this )
65 {
66     (void)p_this;
67 }
68
69 /* "specs" : http://phobos.apple.com/static/iTunesRSS.html */
70 static int Demux( demux_t *p_demux )
71 {
72     bool b_item = false;
73     bool b_image = false;
74     int i_ret;
75
76     xml_t *p_xml;
77     xml_reader_t *p_xml_reader;
78     char *psz_elname = NULL;
79     char *psz_item_mrl = NULL;
80     char *psz_item_size = NULL;
81     char *psz_item_type = NULL;
82     char *psz_item_name = NULL;
83     char *psz_item_date = NULL;
84     char *psz_item_author = NULL;
85     char *psz_item_category = NULL;
86     char *psz_item_duration = NULL;
87     char *psz_item_keywords = NULL;
88     char *psz_item_subtitle = NULL;
89     char *psz_item_summary = NULL;
90     char *psz_art_url = NULL;
91     int i_type;
92     input_item_t *p_input;
93
94     INIT_PLAYLIST_STUFF;
95
96     p_xml = xml_Create( p_demux );
97     if( !p_xml )
98         goto error;
99
100     p_xml_reader = xml_ReaderCreate( p_xml, p_demux->s );
101     if( !p_xml_reader )
102         goto error;
103
104     /* xml */
105     /* check root node */
106     if( xml_ReaderRead( p_xml_reader ) != 1 )
107     {
108         msg_Err( p_demux, "invalid file (no root node)" );
109         goto error;
110     }
111
112     while( xml_ReaderNodeType( p_xml_reader ) == XML_READER_NONE )
113     {
114         if( xml_ReaderRead( p_xml_reader ) != 1 )
115         {
116             msg_Err( p_demux, "invalid file (no root node)" );
117             goto error;
118         }
119     }
120
121     if( xml_ReaderNodeType( p_xml_reader ) != XML_READER_STARTELEM ||
122         ( psz_elname = xml_ReaderName( p_xml_reader ) ) == NULL ||
123         strcmp( psz_elname, "rss" ) )
124     {
125         msg_Err( p_demux, "invalid root node %i, %s",
126                  xml_ReaderNodeType( p_xml_reader ), psz_elname );
127         goto error;
128     }
129     FREENULL( psz_elname );
130
131     while( (i_ret = xml_ReaderRead( p_xml_reader )) == 1 )
132     {
133         // Get the node type
134         i_type = xml_ReaderNodeType( p_xml_reader );
135         switch( i_type )
136         {
137             // Error
138             case -1:
139                 goto error;
140
141             case XML_READER_STARTELEM:
142             {
143                 // Read the element name
144                 free( psz_elname );
145                 psz_elname = xml_ReaderName( p_xml_reader );
146                 if( !psz_elname )
147                     goto error;
148
149                 if( !strcmp( psz_elname, "item" ) )
150                 {
151                     b_item = true;
152                 }
153                 else if( !strcmp( psz_elname, "image" ) )
154                 {
155                     b_image = true;
156                 }
157
158                 // Read the attributes
159                 while( xml_ReaderNextAttr( p_xml_reader ) == VLC_SUCCESS )
160                 {
161                     char *psz_name = xml_ReaderName( p_xml_reader );
162                     char *psz_value = xml_ReaderValue( p_xml_reader );
163                     if( !psz_name || !psz_value )
164                     {
165                         free( psz_name );
166                         free( psz_value );
167                         goto error;
168                     }
169
170                     if( !strcmp( psz_elname, "enclosure" ) )
171                     {
172                         if( !strcmp( psz_name, "url" ) )
173                         {
174                             free( psz_item_mrl );
175                             psz_item_mrl = psz_value;
176                         }
177                         else if( !strcmp( psz_name, "length" ) )
178                         {
179                             free( psz_item_size );
180                             psz_item_size = psz_value;
181                         }
182                         else if( !strcmp( psz_name, "type" ) )
183                         {
184                             free( psz_item_type );
185                             psz_item_type = psz_value;
186                         }
187                         else
188                         {
189                             msg_Dbg( p_demux,"unhandled attribure %s in element %s",
190                                      psz_name, psz_elname );
191                             free( psz_value );
192                         }
193                     }
194                     else
195                     {
196                         msg_Dbg( p_demux,"unhandled attribure %s in element %s",
197                                   psz_name, psz_elname );
198                         free( psz_value );
199                     }
200                     free( psz_name );
201                 }
202                 break;
203             }
204             case XML_READER_TEXT:
205             {
206                 char *psz_text = xml_ReaderValue( p_xml_reader );
207
208 #define SET_DATA( field, name )                 \
209     else if( !strcmp( psz_elname, name ) )      \
210     {                                           \
211         field = psz_text;                       \
212     }
213                 /* item specific meta data */
214                 if( b_item == true )
215                 {
216                     if( !strcmp( psz_elname, "title" ) )
217                     {
218                         psz_item_name = psz_text;
219                     }
220                     else if( !strcmp( psz_elname, "itunes:author" ) ||
221                              !strcmp( psz_elname, "author" ) )
222                     { /* <author> isn't standard iTunes podcast stuff */
223                         psz_item_author = psz_text;
224                     }
225                     else if( !strcmp( psz_elname, "itunes:summary" ) ||
226                              !strcmp( psz_elname, "description" ) )
227                     { /* <description> isn't standard iTunes podcast stuff */
228                         psz_item_summary = psz_text;
229                     }
230                     SET_DATA( psz_item_date, "pubDate" )
231                     SET_DATA( psz_item_category, "itunes:category" )
232                     SET_DATA( psz_item_duration, "itunes:duration" )
233                     SET_DATA( psz_item_keywords, "itunes:keywords" )
234                     SET_DATA( psz_item_subtitle, "itunes:subtitle" )
235                     else
236                         free( psz_text );
237                 }
238 #undef SET_DATA
239
240                 /* toplevel meta data */
241                 else if( b_image == false )
242                 {
243                     if( !strcmp( psz_elname, "title" ) )
244                     {
245                         input_item_SetName( p_current_input, psz_text );
246                     }
247 #define ADD_GINFO( info, name ) \
248     else if( !strcmp( psz_elname, name ) ) \
249     { \
250         input_item_AddInfo( p_current_input, _("Podcast Info"), \
251                                 _( info ), "%s", psz_text ); \
252     }
253                     ADD_GINFO( "Podcast Link", "link" )
254                     ADD_GINFO( "Podcast Copyright", "copyright" )
255                     ADD_GINFO( "Podcast Category", "itunes:category" )
256                     ADD_GINFO( "Podcast Keywords", "itunes:keywords" )
257                     ADD_GINFO( "Podcast Subtitle", "itunes:subtitle" )
258 #undef ADD_GINFO
259                     else if( !strcmp( psz_elname, "itunes:summary" ) ||
260                              !strcmp( psz_elname, "description" ) )
261                     { /* <description> isn't standard iTunes podcast stuff */
262                         input_item_AddInfo( p_current_input,
263                             _( "Podcast Info" ), _( "Podcast Summary" ),
264                             "%s", psz_text );
265                     }
266                     free( psz_text );
267                 }
268                 else
269                 {
270                     if( !strcmp( psz_elname, "url" ) )
271                     {
272                         free( psz_art_url );
273                         psz_art_url = psz_text;
274                     }
275                     else
276                     {
277                         msg_Dbg( p_demux, "unhandled text in element '%s'",
278                                  psz_elname );
279                         free( psz_text );
280                     }
281                 }
282                 break;
283             }
284             // End element
285             case XML_READER_ENDELEM:
286             {
287                 // Read the element name
288                 free( psz_elname );
289                 psz_elname = xml_ReaderName( p_xml_reader );
290                 if( !psz_elname )
291                     goto error;
292                 if( !strcmp( psz_elname, "item" ) )
293                 {
294                     if( psz_item_mrl == NULL )
295                     {
296                         msg_Err( p_demux, "invalid XML (no enclosure markup)" );
297                         goto error;
298                     }
299                     p_input = input_item_New( p_demux, psz_item_mrl, psz_item_name );
300                     if( p_input == NULL ) break;
301 #define ADD_INFO( info, field ) \
302     if( field ) { input_item_AddInfo( p_input, \
303                             _( "Podcast Info" ),  _( info ), "%s", field ); }
304                     ADD_INFO( "Podcast Publication Date", psz_item_date  );
305                     ADD_INFO( "Podcast Author", psz_item_author );
306                     ADD_INFO( "Podcast Subcategory", psz_item_category );
307                     ADD_INFO( "Podcast Duration", psz_item_duration );
308                     ADD_INFO( "Podcast Keywords", psz_item_keywords );
309                     ADD_INFO( "Podcast Subtitle", psz_item_subtitle );
310                     ADD_INFO( "Podcast Summary", psz_item_summary );
311                     ADD_INFO( "Podcast Type", psz_item_type );
312 #undef ADD_INFO
313
314                     /* Set the duration if available */
315                     if( psz_item_duration )
316                         input_item_SetDuration( p_input, strTimeToMTime( psz_item_duration ) );
317                     /* Add the global art url to this item, if any */
318                     if( psz_art_url )
319                         input_item_SetArtURL( p_input, psz_art_url );
320
321                     if( psz_item_size )
322                     {
323                         input_item_AddInfo( p_input,
324                                                 _( "Podcast Info" ),
325                                                 _( "Podcast Size" ),
326                                                 "%s bytes",
327                                                 psz_item_size );
328                     }
329                     input_item_AddSubItem( p_current_input, p_input );
330                     vlc_gc_decref( p_input );
331                     FREENULL( psz_item_name );
332                     FREENULL( psz_item_mrl );
333                     FREENULL( psz_item_size );
334                     FREENULL( psz_item_type );
335                     FREENULL( psz_item_date );
336                     FREENULL( psz_item_author );
337                     FREENULL( psz_item_category );
338                     FREENULL( psz_item_duration );
339                     FREENULL( psz_item_keywords );
340                     FREENULL( psz_item_subtitle );
341                     FREENULL( psz_item_summary );
342                     b_item = false;
343                 }
344                 else if( !strcmp( psz_elname, "image" ) )
345                 {
346                     b_image = false;
347                 }
348                 free( psz_elname );
349                 psz_elname = strdup( "" );
350
351                 break;
352             }
353         }
354     }
355
356     if( i_ret != 0 )
357     {
358         msg_Warn( p_demux, "error while parsing data" );
359     }
360
361     free( psz_art_url );
362     free( psz_elname );
363     xml_ReaderDelete( p_xml, p_xml_reader );
364     xml_Delete( p_xml );
365
366     HANDLE_PLAY_AND_RELEASE;
367     return 0; /* Needed for correct operation of go back */
368
369 error:
370     free( psz_item_name );
371     free( psz_item_mrl );
372     free( psz_item_size );
373     free( psz_item_type );
374     free( psz_item_date );
375     free( psz_item_author );
376     free( psz_item_category );
377     free( psz_item_duration );
378     free( psz_item_keywords );
379     free( psz_item_subtitle );
380     free( psz_item_summary );
381     free( psz_art_url );
382     free( psz_elname );
383
384     if( p_xml_reader )
385         xml_ReaderDelete( p_xml, p_xml_reader );
386     xml_Delete( p_xml );
387
388     HANDLE_PLAY_AND_RELEASE;
389     return -1;
390 }
391
392 static int Control( demux_t *p_demux, int i_query, va_list args )
393 {
394     VLC_UNUSED(p_demux); VLC_UNUSED(i_query); VLC_UNUSED(args);
395     return VLC_EGENERIC;
396 }
397
398 static mtime_t strTimeToMTime( const char *psz )
399 {
400     int h, m, s;
401     switch( sscanf( psz, "%u:%u:%u", &h, &m, &s ) )
402     {
403     case 3:
404         return (mtime_t)( ( h*60 + m )*60 + s ) * 1000000;
405     case 2:
406         return (mtime_t)( h*60 + m ) * 1000000;
407         break;
408     default:
409         return -1;
410     }
411 }