Remove unnedeeded msg_Error.
[vlc.git] / modules / video_filter / rss.c
1 /*****************************************************************************
2  * rss.c : rss/atom feed display video plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2003-2006 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  * Atom : http://www.ietf.org/rfc/rfc4287.txt
26  * RSS : http://www.rssboard.org/rss-specification
27  *****************************************************************************/
28
29 /*****************************************************************************
30  * Preamble
31  *****************************************************************************/
32
33 #ifdef HAVE_CONFIG_H
34 # include "config.h"
35 #endif
36
37 #include <vlc_common.h>
38 #include <vlc_plugin.h>
39 #include <vlc_vout.h>
40
41 #include "vlc_filter.h"
42 #include "vlc_block.h"
43 #include "vlc_osd.h"
44
45 #include "vlc_block.h"
46 #include "vlc_stream.h"
47 #include "vlc_xml.h"
48 #include <vlc_charset.h>
49
50 #include "vlc_image.h"
51
52 #include <time.h>
53
54 /*****************************************************************************
55  * Local prototypes
56  *****************************************************************************/
57 static int  CreateFilter ( vlc_object_t * );
58 static void DestroyFilter( vlc_object_t * );
59 static subpicture_t *Filter( filter_t *, mtime_t );
60
61 static int FetchRSS( filter_t * );
62 static void FreeRSS( filter_t * );
63
64 static const int pi_color_values[] = {
65                0xf0000000, 0x00000000, 0x00808080, 0x00C0C0C0,
66                0x00FFFFFF, 0x00800000, 0x00FF0000, 0x00FF00FF, 0x00FFFF00,
67                0x00808000, 0x00008000, 0x00008080, 0x0000FF00, 0x00800080,
68                0x00000080, 0x000000FF, 0x0000FFFF};
69 static const char *const ppsz_color_descriptions[] = {
70                N_("Default"), N_("Black"),
71                N_("Gray"), N_("Silver"), N_("White"), N_("Maroon"), N_("Red"),
72                N_("Fuchsia"), N_("Yellow"), N_("Olive"), N_("Green"),
73                N_("Teal"), N_("Lime"), N_("Purple"), N_("Navy"), N_("Blue"),
74                N_("Aqua") };
75
76 /*****************************************************************************
77  * filter_sys_t: rss filter descriptor
78  *****************************************************************************/
79
80 struct rss_item_t
81 {
82     char *psz_title;
83     char *psz_description;
84     char *psz_link;
85 };
86
87 struct rss_feed_t
88 {
89     char *psz_title;
90     char *psz_description;
91     char *psz_link;
92     char *psz_image;
93     picture_t *p_pic;
94
95     int i_items;
96     struct rss_item_t *p_items;
97 };
98
99 struct filter_sys_t
100 {
101     vlc_mutex_t lock;
102     vlc_mutex_t *p_lock;
103
104     int i_xoff, i_yoff;  /* offsets for the display string in the video window */
105     int i_pos; /* permit relative positioning (top, bottom, left, right, center) */
106     int i_speed;
107     int i_length;
108
109     char *psz_marquee;    /* marquee string */
110
111     text_style_t *p_style; /* font control */
112
113     mtime_t last_date;
114
115     char *psz_urls;
116     int i_feeds;
117     struct rss_feed_t *p_feeds;
118
119     int i_ttl;
120     time_t t_last_update;
121     bool b_images;
122     int i_title;
123
124     int i_cur_feed;
125     int i_cur_item;
126     int i_cur_char;
127 };
128
129 #define MSG_TEXT N_("Feed URLs")
130 #define MSG_LONGTEXT N_("RSS/Atom feed '|' (pipe) seperated URLs.")
131 #define SPEED_TEXT N_("Speed of feeds")
132 #define SPEED_LONGTEXT N_("Speed of the RSS/Atom feeds in microseconds (bigger is slower).")
133 #define LENGTH_TEXT N_("Max length")
134 #define LENGTH_LONGTEXT N_("Maximum number of characters displayed on the " \
135                 "screen." )
136 #define TTL_TEXT N_("Refresh time")
137 #define TTL_LONGTEXT N_("Number of seconds between each forced refresh " \
138         "of the feeds. 0 means that the feeds are never updated." )
139 #define IMAGE_TEXT N_("Feed images")
140 #define IMAGE_LONGTEXT N_("Display feed images if available.")
141
142 #define POSX_TEXT N_("X offset")
143 #define POSX_LONGTEXT N_("X offset, from the left screen edge." )
144 #define POSY_TEXT N_("Y offset")
145 #define POSY_LONGTEXT N_("Y offset, down from the top." )
146 #define OPACITY_TEXT N_("Opacity")
147 #define OPACITY_LONGTEXT N_("Opacity (inverse of transparency) of " \
148     "overlay text. 0 = transparent, 255 = totally opaque." )
149
150 #define SIZE_TEXT N_("Font size, pixels")
151 #define SIZE_LONGTEXT N_("Font size, in pixels. Default is -1 (use default " \
152     "font size)." )
153
154 #define COLOR_TEXT N_("Color")
155 #define COLOR_LONGTEXT N_("Color of the text that will be rendered on "\
156     "the video. This must be an hexadecimal (like HTML colors). The first two "\
157     "chars are for red, then green, then blue. #000000 = black, #FF0000 = red,"\
158     " #00FF00 = green, #FFFF00 = yellow (red + green), #FFFFFF = white" )
159
160 #define POS_TEXT N_("Text position")
161 #define POS_LONGTEXT N_( \
162   "You can enforce the text position on the video " \
163   "(0=center, 1=left, 2=right, 4=top, 8=bottom; you can " \
164   "also use combinations of these values, eg 6 = top-right).")
165
166 #define TITLE_TEXT N_("Title display mode")
167 #define TITLE_LONGTEXT N_("Title display mode. Default is 0 (hidden) if the feed has an image and feed images are enabled, 1 otherwise.")
168
169 static const int pi_pos_values[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
170 static const char *const ppsz_pos_descriptions[] =
171      { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
172      N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
173
174 enum title_modes {
175     default_title=-1,
176     hide_title,
177     prepend_title,
178     scroll_title };
179
180 static const int pi_title_modes[] = { default_title, hide_title, prepend_title, scroll_title };
181 static const char *const ppsz_title_modes[] =
182     { N_("Default"), N_("Don't show"), N_("Always visible"), N_("Scroll with feed") };
183
184 #define CFG_PREFIX "rss-"
185
186 /*****************************************************************************
187  * Module descriptor
188  *****************************************************************************/
189 vlc_module_begin();
190     set_capability( "sub filter", 1 );
191     set_shortname( "RSS / Atom" );
192     set_callbacks( CreateFilter, DestroyFilter );
193     set_category( CAT_VIDEO );
194     set_subcategory( SUBCAT_VIDEO_SUBPIC );
195     add_string( CFG_PREFIX "urls", "rss", NULL, MSG_TEXT, MSG_LONGTEXT, false );
196
197     set_section( N_("Position"), NULL );
198     add_integer( CFG_PREFIX "x", 0, NULL, POSX_TEXT, POSX_LONGTEXT, true );
199     add_integer( CFG_PREFIX "y", 0, NULL, POSY_TEXT, POSY_LONGTEXT, true );
200     add_integer( CFG_PREFIX "position", -1, NULL, POS_TEXT, POS_LONGTEXT, false );
201         change_integer_list( pi_pos_values, ppsz_pos_descriptions, 0 );
202
203     set_section( N_("Font"), NULL );
204     /* 5 sets the default to top [1] left [4] */
205     add_integer_with_range( CFG_PREFIX "opacity", 255, 0, 255, NULL,
206         OPACITY_TEXT, OPACITY_LONGTEXT, false );
207     add_integer( CFG_PREFIX "color", 0xFFFFFF, NULL, COLOR_TEXT, COLOR_LONGTEXT,
208                   false );
209         change_integer_list( pi_color_values, ppsz_color_descriptions, 0 );
210     add_integer( CFG_PREFIX "size", -1, NULL, SIZE_TEXT, SIZE_LONGTEXT, false );
211
212     set_section( N_("Misc"), NULL );
213     add_integer( CFG_PREFIX "speed", 100000, NULL, SPEED_TEXT, SPEED_LONGTEXT,
214                  false );
215     add_integer( CFG_PREFIX "length", 60, NULL, LENGTH_TEXT, LENGTH_LONGTEXT,
216                  false );
217     add_integer( CFG_PREFIX "ttl", 1800, NULL, TTL_TEXT, TTL_LONGTEXT, false );
218     add_bool( CFG_PREFIX "images", 1, NULL, IMAGE_TEXT, IMAGE_LONGTEXT, false );
219     add_integer( CFG_PREFIX "title", default_title, NULL, TITLE_TEXT, TITLE_LONGTEXT, false );
220         change_integer_list( pi_title_modes, ppsz_title_modes, 0 );
221
222     set_description( N_("RSS and Atom feed display") );
223     add_shortcut( "rss" );
224     add_shortcut( "atom" );
225 vlc_module_end();
226
227 static const char *const ppsz_filter_options[] = {
228     "urls", "x", "y", "position", "color", "size", "speed", "length",
229     "ttl", "images", "title", NULL
230 };
231
232 /*****************************************************************************
233  * CreateFilter: allocates RSS video filter
234  *****************************************************************************/
235 static int CreateFilter( vlc_object_t *p_this )
236 {
237     filter_t *p_filter = (filter_t *)p_this;
238     filter_sys_t *p_sys;
239     int i_feed;
240
241     /* Allocate structure */
242     p_sys = p_filter->p_sys = malloc( sizeof( filter_sys_t ) );
243     if( p_sys == NULL )
244         return VLC_ENOMEM;
245
246     vlc_mutex_init( &p_sys->lock );
247     vlc_mutex_lock( &p_sys->lock );
248
249     config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
250                        p_filter->p_cfg );
251
252     p_sys->psz_urls = var_CreateGetString( p_filter, CFG_PREFIX "urls" );
253     p_sys->i_title = var_CreateGetInteger( p_filter, CFG_PREFIX "title" );
254     p_sys->i_cur_feed = 0;
255     p_sys->i_cur_item = p_sys->i_title == scroll_title ? -1 : 0;
256     p_sys->i_cur_char = 0;
257     p_sys->i_feeds = 0;
258     p_sys->p_feeds = NULL;
259     p_sys->i_speed = var_CreateGetInteger( p_filter, CFG_PREFIX "speed" );
260     p_sys->i_length = var_CreateGetInteger( p_filter, CFG_PREFIX "length" );
261     p_sys->i_ttl = __MAX( 0, var_CreateGetInteger( p_filter, CFG_PREFIX "ttl" ) );
262     p_sys->b_images = var_CreateGetBool( p_filter, CFG_PREFIX "images" );
263
264     p_sys->psz_marquee = (char *)malloc( p_sys->i_length + 1 );
265     if( p_sys->psz_marquee == NULL )
266     {
267         vlc_mutex_unlock( &p_sys->lock );
268         vlc_mutex_destroy( &p_sys->lock );
269         free( p_sys );
270         return VLC_ENOMEM;
271     }
272     p_sys->psz_marquee[p_sys->i_length] = '\0';
273
274     p_sys->p_style = malloc( sizeof( text_style_t ));
275     if( p_sys->p_style == NULL )
276     {
277         free( p_sys->psz_marquee );
278         vlc_mutex_unlock( &p_sys->lock );
279         vlc_mutex_destroy( &p_sys->lock );
280         free( p_sys );
281         return VLC_ENOMEM;
282     }
283     memcpy( p_sys->p_style, &default_text_style, sizeof( text_style_t ));
284
285     p_sys->i_xoff = var_CreateGetInteger( p_filter, CFG_PREFIX "x" );
286     p_sys->i_yoff = var_CreateGetInteger( p_filter, CFG_PREFIX "y" );
287     p_sys->i_pos = var_CreateGetInteger( p_filter, CFG_PREFIX "position" );
288     p_sys->p_style->i_font_alpha = 255 - var_CreateGetInteger( p_filter, CFG_PREFIX "opacity" );
289     p_sys->p_style->i_font_color = var_CreateGetInteger( p_filter, CFG_PREFIX "color" );
290     p_sys->p_style->i_font_size = var_CreateGetInteger( p_filter, CFG_PREFIX "size" );
291
292     if( p_sys->b_images == true && p_sys->p_style->i_font_size == -1 )
293     {
294         msg_Warn( p_filter, "rrs-size wasn't specified. Feed images will thus be displayed without being resized" );
295     }
296
297     if( FetchRSS( p_filter ) )
298     {
299         msg_Err( p_filter, "failed while fetching RSS ... too bad" );
300         free( p_sys->p_style );
301         free( p_sys->psz_marquee );
302         vlc_mutex_unlock( &p_sys->lock );
303         vlc_mutex_destroy( &p_sys->lock );
304         free( p_sys );
305         return VLC_EGENERIC;
306     }
307     p_sys->t_last_update = time( NULL );
308
309     if( p_sys->i_feeds == 0 )
310     {
311         free( p_sys->p_style );
312         free( p_sys->psz_marquee );
313         vlc_mutex_unlock( &p_sys->lock );
314         vlc_mutex_destroy( &p_sys->lock );
315         free( p_sys );
316         return VLC_EGENERIC;
317     }
318     for( i_feed=0; i_feed < p_sys->i_feeds; i_feed ++ )
319     {
320         if( p_sys->p_feeds[i_feed].i_items == 0 )
321         {
322             free( p_sys->p_style );
323             free( p_sys->psz_marquee );
324             FreeRSS( p_filter );
325             vlc_mutex_unlock( &p_sys->lock );
326             vlc_mutex_destroy( &p_sys->lock );
327             free( p_sys );
328             return VLC_EGENERIC;
329         }
330     }
331     /* Misc init */
332     p_filter->pf_sub_filter = Filter;
333     p_sys->last_date = (mtime_t)0;
334
335     vlc_mutex_unlock( &p_sys->lock );
336
337     return VLC_SUCCESS;
338 }
339 /*****************************************************************************
340  * DestroyFilter: destroy RSS video filter
341  *****************************************************************************/
342 static void DestroyFilter( vlc_object_t *p_this )
343 {
344     filter_t *p_filter = (filter_t *)p_this;
345     filter_sys_t *p_sys = p_filter->p_sys;
346
347     vlc_mutex_lock( &p_sys->lock );
348
349     free( p_sys->p_style );
350     free( p_sys->psz_marquee );
351     free( p_sys->psz_urls );
352     FreeRSS( p_filter );
353     vlc_mutex_unlock( &p_sys->lock );
354     vlc_mutex_destroy( &p_sys->lock );
355     free( p_sys );
356
357     /* Delete the RSS variables */
358     var_Destroy( p_filter, CFG_PREFIX "urls" );
359     var_Destroy( p_filter, CFG_PREFIX "speed" );
360     var_Destroy( p_filter, CFG_PREFIX "length" );
361     var_Destroy( p_filter, CFG_PREFIX "ttl" );
362     var_Destroy( p_filter, CFG_PREFIX "images" );
363     var_Destroy( p_filter, CFG_PREFIX "x" );
364     var_Destroy( p_filter, CFG_PREFIX "y" );
365     var_Destroy( p_filter, CFG_PREFIX "position" );
366     var_Destroy( p_filter, CFG_PREFIX "color");
367     var_Destroy( p_filter, CFG_PREFIX "opacity");
368     var_Destroy( p_filter, CFG_PREFIX "size");
369     var_Destroy( p_filter, CFG_PREFIX "title" );
370 }
371
372 /****************************************************************************
373  * Filter: the whole thing
374  ****************************************************************************
375  * This function outputs subpictures at regular time intervals.
376  ****************************************************************************/
377 static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
378 {
379     filter_sys_t *p_sys = p_filter->p_sys;
380     subpicture_t *p_spu;
381     video_format_t fmt;
382     subpicture_region_t *p_region;
383
384     int i_feed, i_item;
385
386     struct rss_feed_t *p_feed;
387
388     memset( &fmt, 0, sizeof(video_format_t) );
389
390     vlc_mutex_lock( &p_sys->lock );
391
392     if( p_sys->last_date
393        + ( p_sys->i_cur_char == 0 && p_sys->i_cur_item == ( p_sys->i_title == scroll_title ? -1 : 0 ) ? 5 : 1 )
394            /* ( ... ? 5 : 1 ) means "wait 5 times more for the 1st char" */
395        * p_sys->i_speed > date )
396     {
397         vlc_mutex_unlock( &p_sys->lock );
398         return NULL;
399     }
400
401     /* Do we need to update the feeds ? */
402     if( p_sys->i_ttl
403         && time( NULL ) > p_sys->t_last_update + (time_t)p_sys->i_ttl )
404     {
405         msg_Dbg( p_filter, "Forcing update of all the RSS feeds" );
406         if( FetchRSS( p_filter ) )
407         {
408             msg_Err( p_filter, "Failed while fetching RSS ... too bad" );
409             vlc_mutex_unlock( &p_sys->lock );
410             return NULL; /* FIXME : we most likely messed up all the data,
411                           * so we might need to do something about it */
412         }
413         p_sys->t_last_update = time( NULL );
414     }
415
416     p_sys->last_date = date;
417     p_sys->i_cur_char++;
418     if( p_sys->i_cur_item == -1 ? p_sys->p_feeds[p_sys->i_cur_feed].psz_title[p_sys->i_cur_char] == 0 : p_sys->p_feeds[p_sys->i_cur_feed].p_items[p_sys->i_cur_item].psz_title[p_sys->i_cur_char] == 0 )
419     {
420         p_sys->i_cur_char = 0;
421         p_sys->i_cur_item++;
422         if( p_sys->i_cur_item >= p_sys->p_feeds[p_sys->i_cur_feed].i_items )
423         {
424             if( p_sys->i_title == scroll_title )
425                 p_sys->i_cur_item = -1;
426             else
427                 p_sys->i_cur_item = 0;
428             p_sys->i_cur_feed = (p_sys->i_cur_feed + 1)%p_sys->i_feeds;
429         }
430     }
431
432     p_spu = p_filter->pf_sub_buffer_new( p_filter );
433     if( !p_spu )
434     {
435         vlc_mutex_unlock( &p_sys->lock );
436         return NULL;
437     }
438
439     fmt.i_chroma = VLC_FOURCC('T','E','X','T');
440
441     p_spu->p_region = p_spu->pf_create_region( VLC_OBJECT(p_filter), &fmt );
442     if( !p_spu->p_region )
443     {
444         p_filter->pf_sub_buffer_del( p_filter, p_spu );
445         vlc_mutex_unlock( &p_sys->lock );
446         return NULL;
447     }
448
449     /* Generate the string that will be displayed. This string is supposed to
450        be p_sys->i_length characters long. */
451     i_item = p_sys->i_cur_item;
452     i_feed = p_sys->i_cur_feed;
453     p_feed = &p_sys->p_feeds[i_feed];
454
455     if( ( p_feed->p_pic && p_sys->i_title == default_title )
456         || p_sys->i_title == hide_title )
457     {
458         /* Don't display the feed's title if we have an image */
459         snprintf( p_sys->psz_marquee, p_sys->i_length, "%s",
460                   p_sys->p_feeds[i_feed].p_items[i_item].psz_title
461                   +p_sys->i_cur_char );
462     }
463     else if( ( !p_feed->p_pic && p_sys->i_title == default_title )
464              || p_sys->i_title == prepend_title )
465     {
466         snprintf( p_sys->psz_marquee, p_sys->i_length, "%s : %s",
467                   p_sys->p_feeds[i_feed].psz_title,
468                   p_sys->p_feeds[i_feed].p_items[i_item].psz_title
469                   +p_sys->i_cur_char );
470     }
471     else /* scrolling title */
472     {
473         if( i_item == -1 )
474             snprintf( p_sys->psz_marquee, p_sys->i_length, "%s : %s",
475                       p_sys->p_feeds[i_feed].psz_title + p_sys->i_cur_char,
476                       p_sys->p_feeds[i_feed].p_items[i_item+1].psz_title );
477         else
478             snprintf( p_sys->psz_marquee, p_sys->i_length, "%s",
479                       p_sys->p_feeds[i_feed].p_items[i_item].psz_title
480                       +p_sys->i_cur_char );
481     }
482
483     while( strlen( p_sys->psz_marquee ) < (unsigned int)p_sys->i_length )
484     {
485         i_item++;
486         if( i_item == p_sys->p_feeds[i_feed].i_items ) break;
487         snprintf( strchr( p_sys->psz_marquee, 0 ),
488                   p_sys->i_length - strlen( p_sys->psz_marquee ),
489                   " - %s",
490                   p_sys->p_feeds[i_feed].p_items[i_item].psz_title );
491     }
492
493     /* Calls to snprintf might split multibyte UTF8 chars ...
494      * which freetype doesn't like. */
495     {
496         char *a = strdup( p_sys->psz_marquee );
497         char *a2 = a;
498         char *b = p_sys->psz_marquee;
499         EnsureUTF8( p_sys->psz_marquee );
500         /* we want to use ' ' instead of '?' for erroneous chars */
501         while( *b != '\0' )
502         {
503             if( *b != *a ) *b = ' ';
504             b++;a++;
505         }
506         free( a2 );
507     }
508
509     p_spu->p_region->psz_text = strdup(p_sys->psz_marquee);
510     if( p_sys->p_style->i_font_size > 0 )
511         p_spu->p_region->fmt.i_visible_height = p_sys->p_style->i_font_size;
512     p_spu->i_start = date;
513     p_spu->i_stop  = 0;
514     p_spu->b_ephemer = true;
515
516     /*  where to locate the string: */
517     if( p_sys->i_pos < 0 )
518     {   /*  set to an absolute xy */
519         p_spu->p_region->i_align = OSD_ALIGN_LEFT | OSD_ALIGN_TOP;
520         p_spu->b_absolute = true;
521     }
522     else
523     {   /* set to one of the 9 relative locations */
524         p_spu->p_region->i_align = p_sys->i_pos;
525         p_spu->b_absolute = false;
526     }
527
528     p_spu->i_x = p_sys->i_xoff;
529     p_spu->i_y = p_sys->i_yoff;
530
531     p_spu->i_height = 1;
532     p_spu->p_region->p_style = p_sys->p_style;
533
534     if( p_feed->p_pic )
535     {
536         /* Display the feed's image */
537         picture_t *p_pic = p_feed->p_pic;
538         video_format_t fmt_out;
539
540         memset( &fmt_out, 0, sizeof(video_format_t) );
541
542         fmt_out.i_chroma = VLC_FOURCC('Y','U','V','A');
543         fmt_out.i_aspect = VOUT_ASPECT_FACTOR;
544         fmt_out.i_sar_num = fmt_out.i_sar_den = 1;
545         fmt_out.i_width =
546             fmt_out.i_visible_width = p_pic->p[Y_PLANE].i_visible_pitch;
547         fmt_out.i_height =
548             fmt_out.i_visible_height = p_pic->p[Y_PLANE].i_visible_lines;
549
550         p_region = p_spu->pf_create_region( VLC_OBJECT( p_filter ), &fmt_out );
551         if( !p_region )
552         {
553             msg_Err( p_filter, "cannot allocate SPU region" );
554         }
555         else
556         {
557             vout_CopyPicture( p_filter, &p_region->picture, p_pic );
558             p_spu->p_region->p_next = p_region;
559         }
560
561         /* Offset text to display right next to the image */
562         p_spu->p_region->i_x = p_pic->p[Y_PLANE].i_visible_pitch;
563     }
564
565     vlc_mutex_unlock( &p_sys->lock );
566     return p_spu;
567 }
568
569 /****************************************************************************
570  * RSS related functions
571  ****************************************************************************
572  * You should always lock the p_filter mutex before using any of these
573  * functions
574  ***************************************************************************/
575
576 #undef LoadImage /* do not conflict with Win32 API */
577
578 /****************************************************************************
579  * download and resize image located at psz_url
580  ***************************************************************************/
581 static picture_t *LoadImage( filter_t *p_filter, const char *psz_url )
582 {
583     filter_sys_t *p_sys = p_filter->p_sys;
584     video_format_t fmt_in;
585     video_format_t fmt_out;
586     picture_t *p_orig;
587     picture_t *p_pic = NULL;
588     image_handler_t *p_handler = image_HandlerCreate( p_filter );
589
590     memset( &fmt_in, 0, sizeof(video_format_t) );
591     memset( &fmt_out, 0, sizeof(video_format_t) );
592
593     fmt_out.i_chroma = VLC_FOURCC('Y','U','V','A');
594     p_orig = image_ReadUrl( p_handler, psz_url, &fmt_in, &fmt_out );
595
596     if( !p_orig )
597     {
598         msg_Warn( p_filter, "Unable to read image %s", psz_url );
599     }
600     else if( p_sys->p_style->i_font_size > 0 )
601     {
602
603         fmt_in.i_chroma = VLC_FOURCC('Y','U','V','A');
604         fmt_in.i_height = p_orig->p[Y_PLANE].i_visible_lines;
605         fmt_in.i_width = p_orig->p[Y_PLANE].i_visible_pitch;
606         fmt_out.i_width = p_orig->p[Y_PLANE].i_visible_pitch
607             *p_sys->p_style->i_font_size/p_orig->p[Y_PLANE].i_visible_lines;
608         fmt_out.i_height = p_sys->p_style->i_font_size;
609
610         p_pic = image_Convert( p_handler, p_orig, &fmt_in, &fmt_out );
611         p_orig->pf_release( p_orig );
612         if( !p_pic )
613         {
614             msg_Warn( p_filter, "Error while converting %s", psz_url );
615         }
616     }
617     else
618     {
619         p_pic = p_orig;
620     }
621
622     image_HandlerDelete( p_handler );
623
624     return p_pic;
625 }
626
627 /****************************************************************************
628  * remove all ' ' '\t' '\n' '\r' characters from the begining and end of the
629  * string.
630  ***************************************************************************/
631 static char *removeWhiteChars( char *psz_src )
632 {
633     char *psz_src2 = strdup( psz_src );
634     char *psz_clean = strdup( psz_src2 );
635     char *psz_clean2;
636     int i;
637     while( ( *psz_clean == ' ' || *psz_clean == '\t'
638            || *psz_clean == '\n' || *psz_clean == '\r' )
639            && *psz_clean != '\0' )
640     {
641         psz_clean++;
642     }
643     i = strlen( psz_clean );
644     while( --i > 0 &&
645          ( psz_clean[i] == ' ' || psz_clean[i] == '\t'
646         || psz_clean[i] == '\n' || psz_clean[i] == '\r' ) );
647     psz_clean[i+1] = '\0';
648     psz_clean2 = strdup( psz_clean );
649     free( psz_src2 );
650     return psz_clean2;
651 }
652
653 /****************************************************************************
654  * FetchRSS (or Atom) feeds
655  ***************************************************************************/
656 static int FetchRSS( filter_t *p_filter)
657 {
658     filter_sys_t *p_sys = p_filter->p_sys;
659
660     stream_t *p_stream = NULL;
661     xml_t *p_xml = NULL;
662     xml_reader_t *p_xml_reader = NULL;
663
664     char *psz_eltname = NULL;
665     char *psz_eltvalue = NULL;
666     char *psz_feed = NULL;
667     char *psz_buffer = NULL;
668     char *psz_buffer_2 = NULL;
669
670     int i_feed;
671     int i_item;
672     bool b_is_item;
673     bool b_is_image;
674     int i_int;
675
676     FreeRSS( p_filter );
677     p_sys->i_feeds = 1;
678     i_int = 0;
679     while( p_sys->psz_urls[i_int] != 0 )
680         if( p_sys->psz_urls[i_int++] == '|' )
681             p_sys->i_feeds++;
682     p_sys->p_feeds = (struct rss_feed_t *)malloc( p_sys->i_feeds
683                                 * sizeof( struct rss_feed_t ) );
684
685     p_xml = xml_Create( p_filter );
686     if( !p_xml )
687     {
688         msg_Err( p_filter, "Failed to open XML parser" );
689         return 1;
690     }
691
692     psz_buffer = strdup( p_sys->psz_urls );
693     psz_buffer_2 = psz_buffer; /* keep track so we can free it */
694     for( i_feed = 0; i_feed < p_sys->i_feeds; i_feed++ )
695     {
696         struct rss_feed_t *p_feed = p_sys->p_feeds+i_feed;
697
698         if( psz_buffer == NULL ) break;
699         if( psz_buffer[0] == 0 ) psz_buffer++;
700         psz_feed = psz_buffer;
701         psz_buffer = strchr( psz_buffer, '|' );
702         if( psz_buffer != NULL ) psz_buffer[0] = 0;
703
704         p_feed->psz_title = NULL;
705         p_feed->psz_description = NULL;
706         p_feed->psz_link = NULL;
707         p_feed->psz_image = NULL;
708         p_feed->p_pic = NULL;
709         p_feed->i_items = 0;
710         p_feed->p_items = NULL;
711
712         msg_Dbg( p_filter, "opening %s RSS/Atom feed ...", psz_feed );
713
714         p_stream = stream_UrlNew( p_filter, psz_feed );
715         if( !p_stream )
716         {
717             msg_Err( p_filter, "Failed to open %s for reading", psz_feed );
718             return 1;
719         }
720
721         p_xml_reader = xml_ReaderCreate( p_xml, p_stream );
722         if( !p_xml_reader )
723         {
724             msg_Err( p_filter, "Failed to open %s for parsing", psz_feed );
725             return 1;
726         }
727
728         i_item = 0;
729         b_is_item = false;
730         b_is_image = false;
731
732         while( xml_ReaderRead( p_xml_reader ) == 1 )
733         {
734             switch( xml_ReaderNodeType( p_xml_reader ) )
735             {
736                 // Error
737                 case -1:
738                     return 1;
739
740                 case XML_READER_STARTELEM:
741                     free( psz_eltname );
742                     psz_eltname = NULL;
743                     psz_eltname = xml_ReaderName( p_xml_reader );
744                     if( !psz_eltname )
745                     {
746                         return 1;
747                     }
748 #                   ifdef RSS_DEBUG
749                     msg_Dbg( p_filter, "element name: %s", psz_eltname );
750 #                   endif
751                     if( !strcmp( psz_eltname, "item" ) /* rss */
752                      || !strcmp( psz_eltname, "entry" ) ) /* atom */
753                     {
754                         b_is_item = true;
755                         p_feed->i_items++;
756                         p_feed->p_items = (struct rss_item_t *)realloc( p_feed->p_items, p_feed->i_items * sizeof( struct rss_item_t ) );
757                         p_feed->p_items[p_feed->i_items-1].psz_title = NULL;
758                         p_feed->p_items[p_feed->i_items-1].psz_description
759                                                                      = NULL;
760                         p_feed->p_items[p_feed->i_items-1].psz_link = NULL;
761                     }
762                     else if( !strcmp( psz_eltname, "image" ) ) /* rss */
763                     {
764                         b_is_image = true;
765                     }
766                     else if( !strcmp( psz_eltname, "link" ) ) /* atom */
767                     {
768                         char *psz_href = NULL;
769                         char *psz_rel = NULL;
770                         while( xml_ReaderNextAttr( p_xml_reader )
771                                == VLC_SUCCESS )
772                         {
773                             char *psz_name = xml_ReaderName( p_xml_reader );
774                             char *psz_value = xml_ReaderValue( p_xml_reader );
775                             if( !strcmp( psz_name, "rel" ) )
776                             {
777                                 psz_rel = psz_value;
778                             }
779                             else if( !strcmp( psz_name, "href" ) )
780                             {
781                                 psz_href = psz_value;
782                             }
783                             else
784                             {
785                                 free( psz_value );
786                             }
787                             free( psz_name );
788                         }
789                         if( psz_rel && psz_href )
790                         {
791                             if( !strcmp( psz_rel, "alternate" )
792                                 && b_is_item == false
793                                 && b_is_image == false
794                                 && !p_feed->psz_link )
795                             {
796                                 p_feed->psz_link = psz_href;
797                             }
798                             /* this isn't in the rfc but i found some ... */
799                             else if( ( !strcmp( psz_rel, "logo" )
800                                     || !strcmp( psz_rel, "icon" ) )
801                                     && b_is_item == false
802                                     && b_is_image == false
803                                     && !p_feed->psz_image )
804                             {
805                                 p_feed->psz_image = psz_href;
806                             }
807                             else
808                             {
809                                 free( psz_href );
810                             }
811                         }
812                         else
813                         {
814                             free( psz_href );
815                         }
816                         free( psz_rel );
817                     }
818                     break;
819
820                 case XML_READER_ENDELEM:
821                     free( psz_eltname );
822                     psz_eltname = NULL;
823                     psz_eltname = xml_ReaderName( p_xml_reader );
824                     if( !psz_eltname )
825                     {
826                         return 1;
827                     }
828 #                   ifdef RSS_DEBUG
829                     msg_Dbg( p_filter, "element end : %s", psz_eltname );
830 #                   endif
831                     if( !strcmp( psz_eltname, "item" ) /* rss */
832                      || !strcmp( psz_eltname, "entry" ) ) /* atom */
833                     {
834                         b_is_item = false;
835                         i_item++;
836                     }
837                     else if( !strcmp( psz_eltname, "image" ) ) /* rss */
838                     {
839                         b_is_image = false;
840                     }
841                     free( psz_eltname );
842                     psz_eltname = NULL;
843                     break;
844
845                 case XML_READER_TEXT:
846                     if( !psz_eltname ) break;
847                     psz_eltvalue = xml_ReaderValue( p_xml_reader );
848                     if( !psz_eltvalue )
849                     {
850                         return 1;
851                     }
852                     else
853                     {
854                         char *psz_clean;
855                         psz_clean = removeWhiteChars( psz_eltvalue );
856                         free( psz_eltvalue ); psz_eltvalue = psz_clean;
857                     }
858 #                   ifdef RSS_DEBUG
859                     msg_Dbg( p_filter, "  text : <%s>", psz_eltvalue );
860 #                   endif
861                     if( b_is_item == true )
862                     {
863                         struct rss_item_t *p_item;
864                         p_item = p_feed->p_items+i_item;
865                         if( !strcmp( psz_eltname, "title" ) /* rss/atom */
866                             && !p_item->psz_title )
867                         {
868                             p_item->psz_title = psz_eltvalue;
869                         }
870                         else if( !strcmp( psz_eltname, "link" ) /* rss */
871                                  && !p_item->psz_link )
872                         {
873                             p_item->psz_link = psz_eltvalue;
874                         }
875                         else if((!strcmp( psz_eltname, "description" ) /* rss */
876                               || !strcmp( psz_eltname, "summary" ) ) /* atom */
877                               && !p_item->psz_description )
878                         {
879                             p_item->psz_description = psz_eltvalue;
880                         }
881                         else
882                         {
883                             free( psz_eltvalue );
884                             psz_eltvalue = NULL;
885                         }
886                     }
887                     else if( b_is_image == true )
888                     {
889                         if( !strcmp( psz_eltname, "url" ) /* rss */
890                             && !p_feed->psz_image )
891                         {
892                             p_feed->psz_image = psz_eltvalue;
893                         }
894                         else
895                         {
896                             free( psz_eltvalue );
897                             psz_eltvalue = NULL;
898                         }
899                     }
900                     else
901                     {
902                         if( !strcmp( psz_eltname, "title" ) /* rss/atom */
903                             && !p_feed->psz_title )
904                         {
905                             p_feed->psz_title = psz_eltvalue;
906                         }
907                         else if( !strcmp( psz_eltname, "link" ) /* rss */
908                                  && !p_feed->psz_link )
909                         {
910                             p_feed->psz_link = psz_eltvalue;
911                         }
912                         else if((!strcmp( psz_eltname, "description" ) /* rss */
913                               || !strcmp( psz_eltname, "subtitle" ) ) /* atom */
914                               && !p_feed->psz_description )
915                         {
916                             p_feed->psz_description = psz_eltvalue;
917                         }
918                         else if( ( !strcmp( psz_eltname, "logo" ) /* atom */
919                               || !strcmp( psz_eltname, "icon" ) ) /* atom */
920                               && !p_feed->psz_image )
921                         {
922                             p_feed->psz_image = psz_eltvalue;
923                         }
924                         else
925                         {
926                             free( psz_eltvalue );
927                             psz_eltvalue = NULL;
928                         }
929                     }
930                     break;
931             }
932         }
933
934         if( p_sys->b_images == true
935             && p_feed->psz_image && !p_feed->p_pic )
936         {
937             p_feed->p_pic = LoadImage( p_filter, p_feed->psz_image );
938         }
939
940         if( p_xml_reader && p_xml ) xml_ReaderDelete( p_xml, p_xml_reader );
941         if( p_stream ) stream_Delete( p_stream );
942         msg_Dbg( p_filter, "done with %s RSS/Atom feed", psz_feed );
943     }
944     free( psz_buffer_2 );
945     if( p_xml ) xml_Delete( p_xml );
946
947     return 0;
948 }
949
950 /****************************************************************************
951  * FreeRSS
952  ***************************************************************************/
953 static void FreeRSS( filter_t *p_filter)
954 {
955     filter_sys_t *p_sys = p_filter->p_sys;
956
957     struct rss_item_t *p_item;
958     struct rss_feed_t *p_feed;
959
960     int i_feed;
961     int i_item;
962
963     for( i_feed = 0; i_feed < p_sys->i_feeds; i_feed++ )
964     {
965         p_feed = p_sys->p_feeds+i_feed;
966         for( i_item = 0; i_item < p_feed->i_items; i_item++ )
967         {
968             p_item = p_feed->p_items+i_item;
969             free( p_item->psz_title );
970             free( p_item->psz_link );
971             free( p_item->psz_description );
972         }
973         free( p_feed->p_items );
974         free( p_feed->psz_title);
975         free( p_feed->psz_link );
976         free( p_feed->psz_description );
977         free( p_feed->psz_image );
978         if( p_feed->p_pic != NULL )
979             p_feed->p_pic->pf_release( p_feed->p_pic );
980     }
981     free( p_sys->p_feeds );
982     p_sys->i_feeds = 0;
983 }