src/controler/mediacontrol_audio_video.c: make mediacontrol_showtext static
[vlc.git] / src / osd / osd_parser.c
1 /*****************************************************************************
2  * osd_parser.c - The OSD Menu  parser core code.
3  *****************************************************************************
4  * Copyright (C) 2005 M2X
5  * $Id$
6  *
7  * Authors: Jean-Paul Saman <jpsaman #_at_# m2x dot nl>
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 #include <stdlib.h>
28 #include <string.h>
29
30 #include <vlc/vlc.h>
31 #include <vlc_vout.h>
32 #include <vlc_config.h>
33
34 #include <vlc_keys.h>
35 #include <vlc_image.h>
36 #include <vlc_osd.h>
37 #include <vlc_charset.h>
38
39
40 #undef OSD_MENU_DEBUG
41
42 /*****************************************************************************
43  * Local prototypes
44  *****************************************************************************/
45 static const char *ppsz_button_states[] = { "unselect", "select", "pressed" };
46
47 /* OSD Menu structure support routines */
48 static osd_menu_t   *osd_MenuNew( osd_menu_t *, const char *, int, int );
49 static osd_button_t *osd_ButtonNew( const char *, int, int );
50 static osd_state_t  *osd_StateNew( vlc_object_t *, const char *, const char * );
51
52 static void osd_MenuFree  ( vlc_object_t *, osd_menu_t * );
53 static void osd_ButtonFree( vlc_object_t *, osd_button_t * );
54 static void osd_StatesFree( vlc_object_t *, osd_state_t * );
55
56 static picture_t *osd_LoadImage( vlc_object_t *, const char *);
57
58 /*****************************************************************************
59  * osd_LoadImage: loads the logo image into memory
60  *****************************************************************************/
61 static picture_t *osd_LoadImage( vlc_object_t *p_this, const char *psz_filename )
62 {
63     picture_t *p_pic = NULL;
64     image_handler_t *p_image;
65     video_format_t fmt_in, fmt_out;
66
67     memset( &fmt_in, 0, sizeof(video_format_t) );
68     memset( &fmt_out, 0, sizeof(video_format_t) );
69
70     fmt_out.i_chroma = VLC_FOURCC('Y','U','V','A');
71     p_image = image_HandlerCreate( p_this );
72     if( p_image )
73     {
74         p_pic = image_ReadUrl( p_image, psz_filename, &fmt_in, &fmt_out );
75         image_HandlerDelete( p_image );
76 #if 0
77         p_pic = osd_YuvaYuvp( p_this, p_pic );
78 #endif
79     }
80     else msg_Err( p_this, "unable to handle this chroma" );
81
82     return p_pic;
83 }
84
85 /*****************************************************************************
86  * Create a new Menu structure
87  *****************************************************************************/
88 static osd_menu_t *osd_MenuNew( osd_menu_t *p_menu, const char *psz_path, int i_x, int i_y )
89 {
90     if( !p_menu ) return NULL;
91
92     p_menu->p_state = (osd_menu_state_t *) malloc( sizeof( osd_menu_state_t ) );
93     if( !p_menu->p_state )
94         msg_Err( p_menu, "Memory allocation for OSD Menu state failed" );
95
96     if( psz_path != NULL )
97         p_menu->psz_path = strdup( psz_path );
98     else
99         p_menu->psz_path = NULL;
100     p_menu->i_x = i_x;
101     p_menu->i_y = i_y;
102
103     return p_menu;
104 }
105
106 /*****************************************************************************
107  * Free the menu
108  *****************************************************************************/
109 static void osd_MenuFree( vlc_object_t *p_this, osd_menu_t *p_menu )
110 {
111     msg_Dbg( p_this, "freeing menu" );
112     osd_ButtonFree( p_this, p_menu->p_button );
113     p_menu->p_button = NULL;
114     p_menu->p_last_button = NULL;
115     if( p_menu->psz_path ) free( p_menu->psz_path );
116     p_menu->psz_path = NULL;
117     if( p_menu->p_state ) free( p_menu->p_state );
118     p_menu->p_state = NULL;
119 }
120
121 /*****************************************************************************
122  * Create a new button
123  *****************************************************************************/
124 static osd_button_t *osd_ButtonNew( const char *psz_action, int i_x, int i_y )
125 {
126     osd_button_t *p_button = NULL;
127     p_button = (osd_button_t*) malloc( sizeof(osd_button_t) );
128     if( !p_button )
129         return NULL;
130
131     memset( p_button, 0, sizeof(osd_button_t) );
132     p_button->psz_action = strdup(psz_action);
133     p_button->psz_action_down = NULL;
134     p_button->p_feedback = NULL;
135     p_button->i_x = i_x;
136     p_button->i_y = i_y;
137
138     return p_button;
139 }
140
141 /*****************************************************************************
142  * Free a button
143  *****************************************************************************/
144 static void osd_ButtonFree( vlc_object_t *p_this, osd_button_t *p_button )
145 {
146     osd_button_t *p_current = p_button;
147     osd_button_t *p_next = NULL;
148     osd_button_t *p_prev = NULL;
149
150     /* First walk to the end. */
151     while( p_current->p_next )
152     {
153         p_next = p_current->p_next;
154         p_current = p_next;
155     }
156     /* Then free end first and walk to the start. */
157     while( p_current->p_prev )
158     {
159         msg_Dbg( p_this, "+ freeing button %s [%p]", p_current->psz_action, p_current );
160         p_prev = p_current->p_prev;
161         p_current = p_prev;
162         if( p_current->p_next )
163         {
164             if( p_current->p_next->psz_name )
165                 free( p_current->p_next->psz_name );
166             if( p_current->p_next->psz_action )
167                 free( p_current->p_next->psz_action );
168             if( p_current->p_next->psz_action_down )
169                 free( p_current->p_next->psz_action_down );
170             if( p_current->p_feedback && p_current->p_feedback->p_data_orig )
171                 free( p_current->p_feedback->p_data_orig );
172             if( p_current->p_feedback )
173                 free( p_current->p_feedback );
174
175             p_current->p_next->psz_action_down = NULL;
176             p_current->p_next->psz_action = NULL;
177             p_current->p_next->psz_name = NULL;
178             p_current->p_feedback = NULL;
179
180             /* Free all states first */
181             if( p_current->p_next->p_states )
182                 osd_StatesFree( p_this, p_current->p_next->p_states );
183             p_current->p_next->p_states = NULL;
184             if( p_current->p_next) free( p_current->p_next );
185             p_current->p_next = NULL;
186         }
187
188         if( p_current->p_up )
189         {
190             if( p_current->p_up->psz_name )
191                 free( p_current->p_up->psz_name );
192             if( p_current->p_up->psz_action )
193                 free( p_current->p_up->psz_action );
194             if( p_current->p_up->psz_action_down )
195                 free( p_current->p_up->psz_action_down );
196             if( p_current->p_feedback && p_current->p_feedback->p_data_orig )
197                 free( p_current->p_feedback->p_data_orig );
198             if( p_current->p_feedback )
199                 free( p_current->p_feedback );
200
201             p_current->p_up->psz_action_down = NULL;
202             p_current->p_up->psz_action = NULL;
203             p_current->p_up->psz_name = NULL;
204             p_current->p_feedback = NULL;
205
206             /* Free all states first */
207             if( p_current->p_up->p_states )
208                 osd_StatesFree( p_this, p_current->p_up->p_states );
209             p_current->p_up->p_states = NULL;
210             if( p_current->p_up ) free( p_current->p_up );
211             p_current->p_up = NULL;
212         }
213     }
214     /* Free the last one. */
215     if( p_button )
216     {
217         msg_Dbg( p_this, "+ freeing button %s [%p]", p_button->psz_action, p_button );
218         if( p_button->psz_name ) free( p_button->psz_name );
219         if( p_button->psz_action ) free( p_button->psz_action );
220         if( p_button->psz_action_down ) free( p_button->psz_action_down );
221         if( p_current->p_feedback && p_current->p_feedback->p_data_orig )
222             free( p_current->p_feedback->p_data_orig );
223         if( p_current->p_feedback )
224             free( p_current->p_feedback );
225
226         p_button->psz_name = NULL;
227         p_button->psz_action = NULL;
228         p_button->psz_action_down = NULL;
229         p_current->p_feedback = NULL;
230
231         if( p_button->p_states )
232             osd_StatesFree( p_this, p_button->p_states );
233         p_button->p_states = NULL;
234         free( p_button );
235         p_button = NULL;
236     }
237 }
238
239 /*****************************************************************************
240  * Create a new state image
241  *****************************************************************************/
242 static osd_state_t *osd_StateNew( vlc_object_t *p_this, const char *psz_file, const char *psz_state )
243 {
244     osd_state_t *p_state = NULL;
245     p_state = (osd_state_t*) malloc( sizeof(osd_state_t) );
246     if( !p_state )
247         return NULL;
248
249     memset( p_state, 0, sizeof(osd_state_t) );
250     p_state->p_pic = osd_LoadImage( p_this, psz_file );
251
252     if( psz_state )
253     {
254         p_state->psz_state = strdup( psz_state );
255         if( strncmp( ppsz_button_states[0], psz_state, strlen(ppsz_button_states[0]) ) == 0 )
256             p_state->i_state = OSD_BUTTON_UNSELECT;
257         else if( strncmp( ppsz_button_states[1], psz_state, strlen(ppsz_button_states[1]) ) == 0 )
258             p_state->i_state = OSD_BUTTON_SELECT;
259         else if( strncmp( ppsz_button_states[2], psz_state, strlen(ppsz_button_states[2]) ) == 0 )
260             p_state->i_state = OSD_BUTTON_PRESSED;
261     }
262     return p_state;
263 }
264
265 /*****************************************************************************
266  * Free state images
267  *****************************************************************************/
268 static void osd_StatesFree( vlc_object_t *p_this, osd_state_t *p_states )
269 {
270     osd_state_t *p_state = p_states;
271     osd_state_t *p_next = NULL;
272     osd_state_t *p_prev = NULL;
273
274     while( p_state->p_next )
275     {
276         p_next = p_state->p_next;
277         p_state = p_next;
278     }
279     /* Then free end first and walk to the start. */
280     while( p_state->p_prev )
281     {
282         msg_Dbg( p_this, " |- freeing state %s [%p]", p_state->psz_state, p_state );
283         p_prev = p_state->p_prev;
284         p_state = p_prev;
285         if( p_state->p_next )
286         {
287             if( p_state->p_next->p_pic && p_state->p_next->p_pic->p_data_orig )
288                 free( p_state->p_next->p_pic->p_data_orig );
289             if( p_state->p_next->p_pic ) free( p_state->p_next->p_pic );
290             p_state->p_next->p_pic = NULL;
291             if( p_state->p_next->psz_state ) free( p_state->p_next->psz_state );
292             p_state->p_next->psz_state = NULL;
293             free( p_state->p_next );
294             p_state->p_next = NULL;
295         }
296     }
297     /* Free the last one. */
298     if( p_states )
299     {
300         msg_Dbg( p_this, " |- freeing state %s [%p]", p_state->psz_state, p_states );
301         if( p_states->p_pic && p_states->p_pic->p_data_orig )
302             free( p_states->p_pic->p_data_orig );
303         if( p_states->p_pic ) free( p_states->p_pic );
304         p_states->p_pic = NULL;
305         if( p_state->psz_state ) free( p_state->psz_state );
306         p_state->psz_state = NULL;
307         free( p_states );
308         p_states = NULL;
309     }
310 }
311
312 /*****************************************************************************
313  * osd_ConfigLoader: Load and parse osd text configurationfile
314  *****************************************************************************/
315 int osd_ConfigLoader( vlc_object_t *p_this, const char *psz_file,
316     osd_menu_t **p_menu )
317 {
318     osd_button_t   *p_current = NULL; /* button currently processed */
319     osd_button_t   *p_prev = NULL;    /* previous processed button */
320
321 #define MAX_FILE_PATH 256
322     FILE       *fd = NULL;
323     int        result = 0;
324
325     msg_Dbg( p_this, "opening osd definition file %s", psz_file );
326     fd = utf8_fopen( psz_file, "r" );
327     if( !fd )
328     {
329         msg_Err( p_this, "failed to open OSD definition file %s", psz_file );
330         return VLC_EGENERIC;
331     }
332
333     /* Read first line */
334     if( !feof( fd ) )
335     {
336         char action[25] = "";
337         char path[MAX_FILE_PATH] = "";
338         char *psz_path = NULL;
339         size_t i_len = 0;
340
341         /* override images path ? */
342         psz_path = config_GetPsz( p_this, "osdmenu-file-path" );
343         if( psz_path == NULL )
344         {
345             result = fscanf(fd, "%24s %255s", &action[0], &path[0] );
346         }
347         else
348         {
349             /* psz_path is not null and therefor &path[0] cannot be NULL
350              * it might be null terminated.
351              */
352             strncpy( &path[0], psz_path, MAX_FILE_PATH );
353             free( psz_path );
354             psz_path = NULL;
355         }
356         /* NULL terminate before asking the length of path[] */
357         path[MAX_FILE_PATH-1] = '\0';
358         i_len = strlen(&path[0]);
359         if( i_len == MAX_FILE_PATH )
360             i_len--; /* truncate to prevent buffer overflow */
361 #if defined(WIN32) || defined(UNDER_CE)
362         if( (i_len > 0) && path[i_len] != '\\' )
363             path[i_len] = '\\';
364 #else
365         if( (i_len > 0) && path[i_len] != '/' )
366             path[i_len] = '/';
367 #endif
368         path[i_len+1] = '\0';
369         if( result == 0 || result == EOF )
370             goto error;
371         msg_Dbg( p_this, "%s=%s", &action[0], &path[0] );
372
373         if( i_len == 0 )
374             *p_menu = osd_MenuNew( *p_menu, NULL, 0, 0 );
375         else
376             *p_menu = osd_MenuNew( *p_menu, &path[0], 0, 0 );
377     }
378
379     if( !*p_menu )
380         goto error;
381
382     /* read successive lines */
383     while( !feof( fd ) )
384     {
385         osd_state_t   *p_state_current = NULL; /* button state currently processed */
386         osd_state_t   *p_state_prev = NULL;    /* previous state processed button */
387
388         char cmd[25] = "";
389         char action[25] = "";
390         char state[25]  = "";
391         char file[256]  = "";
392         char path[512]  = "";
393         int  i_x = 0;
394         int  i_y = 0;
395
396         result = fscanf( fd, "%24s %24s (%d,%d)", &cmd[0], &action[0], &i_x, &i_y );
397         if( result == 0 )
398             goto error;
399         if( strncmp( &cmd[0], "action", 6 ) != 0 )
400             break;
401         msg_Dbg( p_this, " + %s hotkey=%s (%d,%d)", &cmd[0], &action[0], i_x, i_y );
402
403         p_prev = p_current;
404         p_current = osd_ButtonNew( &action[0], i_x, i_y );
405         if( !p_current )
406             goto error;
407
408         if( p_prev )
409             p_prev->p_next = p_current;
410         else
411             (*p_menu)->p_button = p_current;
412         p_current->p_prev = p_prev;
413
414         /* parse all states */
415         while( !feof( fd ) )
416         {
417             char type[25] = "";
418
419             result = fscanf( fd, "\t%24s", &state[0] );
420             if( result == 0 )
421                 goto error;
422
423             /* FIXME: We only parse one level deep now */
424             if( strncmp( &state[0], "action", 6 ) == 0 )
425             {
426                 osd_button_t   *p_up = NULL;
427
428                 result = fscanf( fd, "%24s (%d,%d)", &action[0], &i_x, &i_y );
429                 if( result == 0 )
430                     goto error;
431                 /* create new button */
432                 p_up = osd_ButtonNew( &action[0], i_x, i_y );
433                 if( !p_up )
434                     goto error;
435                 /* Link to list */
436                 p_up->p_down = p_current;
437                 p_current->p_up = p_up;
438                 msg_Dbg( p_this, " + (menu up) hotkey=%s (%d,%d)", &action[0], i_x, i_y );
439                 /* Parse type state */
440                 result = fscanf( fd, "\t%24s %24s", &cmd[0], &type[0] );
441                 if( result == 0 )
442                     goto error;
443                 if( strncmp( &cmd[0], "type", 4 ) == 0 )
444                 {
445                     if( strncmp( &type[0], "volume", 6 ) == 0 )
446                     {
447                         (*p_menu)->p_state->p_volume = p_up;
448                         msg_Dbg( p_this, " + type=%s", &type[0] );
449                     }
450                 }
451                 /* Parse range state */
452                 result = fscanf( fd, "\t%24s", &state[0] );
453                 if( result == 0 )
454                     goto error;
455                 /* Parse the range state */
456                 if( strncmp( &state[0], "range", 5 ) == 0 )
457                 {
458                     osd_state_t   *p_range_current = NULL; /* range state currently processed */
459                     osd_state_t   *p_range_prev = NULL;    /* previous state processed range */
460                     int i_index = 0;
461
462                     p_up->b_range = VLC_TRUE;
463
464                     result = fscanf( fd, "\t%24s", &action[0] );
465                     if( result == 0 )
466                         goto error;
467
468                     result = fscanf( fd, "\t%d", &i_index );
469                     if( result == 0 )
470                         goto error;
471
472                     msg_Dbg( p_this, " + (menu up) hotkey down %s, file=%s%s", &action[0], (*p_menu)->psz_path, &file[0] );
473
474                     if( p_up->psz_action_down ) free( p_up->psz_action_down );
475                     p_up->psz_action_down = strdup( &action[0] );
476
477                     /* Parse range contstruction :
478                      * range <hotkey>
479                      *      <state1> <file1>
480                      *
481                      *      <stateN> <fileN>
482                      * end
483                      */
484                     while( !feof( fd ) )
485                     {
486                         result = fscanf( fd, "\t%255s", &file[0] );
487                         if( result == 0 )
488                             goto error;
489                         if( strncmp( &file[0], "end", 3 ) == 0 )
490                             break;
491
492                         p_range_prev = p_range_current;
493
494                         if( (*p_menu)->psz_path )
495                         {
496                             size_t i_path_size = strlen( (*p_menu)->psz_path );
497                             size_t i_file_size = strlen( &file[0] );
498
499                             strncpy( &path[0], (*p_menu)->psz_path, i_path_size );
500                             strncpy( &path[i_path_size], &file[0], 512 - (i_path_size + i_file_size) );
501                             path[ i_path_size + i_file_size ] = '\0';
502
503                             p_range_current = osd_StateNew( p_this, &path[0], "pressed" );
504                         }
505                         else /* absolute paths are used. */
506                             p_range_current = osd_StateNew( p_this, &file[0], "pressed" );
507
508                         if( !p_range_current || !p_range_current->p_pic )
509                             goto error;
510
511                         /* increment the number of ranges for this button */
512                         p_up->i_ranges++;
513
514                         if( p_range_prev )
515                             p_range_prev->p_next = p_range_current;
516                         else
517                             p_up->p_states = p_range_current;
518                         p_range_current->p_prev = p_range_prev;
519
520                         msg_Dbg( p_this, "  |- range=%d, file=%s%s",
521                                 p_up->i_ranges,
522                                 (*p_menu)->psz_path, &file[0] );
523                     }
524                     if( i_index > 0 )
525                     {
526                         osd_state_t *p_range = NULL;
527
528                         /* Find the default index for state range */
529                         p_range = p_up->p_states;
530                         while( (--i_index > 0) && p_range->p_next )
531                         {
532                             osd_state_t *p_temp = NULL;
533                             p_temp = p_range->p_next;
534                             p_range = p_temp;
535                         }
536                         p_up->p_current_state = p_range;
537                     }
538                     else p_up->p_current_state = p_up->p_states;
539
540                 }
541                 result = fscanf( fd, "\t%24s", &state[0] );
542                 if( result == 0 )
543                     goto error;
544                 if( strncmp( &state[0], "end", 3 ) != 0 )
545                     goto error;
546
547                 /* Continue at the beginning of the while() */
548                 continue;
549             }
550
551             /* Parse the range state */
552             if( strncmp( &state[0], "range", 5 ) == 0 )
553             {
554                 osd_state_t   *p_range_current = NULL; /* range state currently processed */
555                 osd_state_t   *p_range_prev = NULL;    /* previous state processed range */
556                 int i_index = 0;
557
558                 p_current->b_range = VLC_TRUE;
559
560                 result = fscanf( fd, "\t%24s", &action[0] );
561                 if( result == 0 )
562                     goto error;
563
564                 result = fscanf( fd, "\t%d", &i_index );
565                 if( result == 0 )
566                     goto error;
567
568                 msg_Dbg( p_this, " + hotkey down %s, file=%s%s", &action[0], (*p_menu)->psz_path, &file[0] );
569                 if( p_current->psz_action_down ) free( p_current->psz_action_down );
570                 p_current->psz_action_down = strdup( &action[0] );
571
572                 /* Parse range contstruction :
573                  * range <hotkey>
574                  *      <state1> <file1>
575                  *
576                  *      <stateN> <fileN>
577                  * end
578                  */
579                 while( !feof( fd ) )
580                 {
581                     result = fscanf( fd, "\t%255s", &file[0] );
582                     if( result == 0 )
583                         goto error;
584                     if( strncmp( &file[0], "end", 3 ) == 0 )
585                         break;
586
587                     p_range_prev = p_range_current;
588
589                     if( (*p_menu)->psz_path )
590                     {
591                         size_t i_path_size = strlen( (*p_menu)->psz_path );
592                         size_t i_file_size = strlen( &file[0] );
593
594                         strncpy( &path[0], (*p_menu)->psz_path, i_path_size );
595                         strncpy( &path[i_path_size], &file[0], 512 - (i_path_size + i_file_size) );
596                         path[ i_path_size + i_file_size ] = '\0';
597
598                         p_range_current = osd_StateNew( p_this, &path[0], "pressed" );
599                     }
600                     else /* absolute paths are used. */
601                         p_range_current = osd_StateNew( p_this, &file[0], "pressed" );
602
603                     if( !p_range_current || !p_range_current->p_pic )
604                         goto error;
605
606                     /* increment the number of ranges for this button */
607                     p_current->i_ranges++;
608
609                     if( p_range_prev )
610                         p_range_prev->p_next = p_range_current;
611                     else
612                         p_current->p_states = p_range_current;
613                     p_range_current->p_prev = p_range_prev;
614
615                     msg_Dbg( p_this, "  |- range=%d, file=%s%s",
616                             p_current->i_ranges,
617                             (*p_menu)->psz_path, &file[0] );
618                 }
619                 if( i_index > 0 )
620                 {
621                     osd_state_t *p_range = NULL;
622
623                     /* Find the default index for state range */
624                     p_range = p_current->p_states;
625                     while( (--i_index > 0) && p_range->p_next )
626                     {
627                         osd_state_t *p_temp = NULL;
628                         p_temp = p_range->p_next;
629                         p_range = p_temp;
630                     }
631                     p_current->p_current_state = p_range;
632                 }
633                 else p_current->p_current_state = p_current->p_states;
634                 /* Continue at the beginning of the while() */
635                 continue;
636             }
637             if( strncmp( &state[0], "end", 3 ) == 0 )
638                 break;
639
640             result = fscanf( fd, "\t%255s", &file[0] );
641             if( result == 0 )
642                 goto error;
643
644             p_state_prev = p_state_current;
645
646             if( ( strncmp( ppsz_button_states[0], &state[0], strlen(ppsz_button_states[0]) ) != 0 ) &&
647                 ( strncmp( ppsz_button_states[1], &state[0], strlen(ppsz_button_states[1]) ) != 0 ) &&
648                 ( strncmp( ppsz_button_states[2], &state[0], strlen(ppsz_button_states[2]) ) != 0 ) )
649             {
650                 msg_Err( p_this, "invalid button state %s for button %s expected %d: unselect, select or pressed)",
651                                     &state[0], &action[0], strlen(&state[0]));
652                 goto error;
653             }
654
655             if( (*p_menu)->psz_path )
656             {
657                 size_t i_path_size = strlen( (*p_menu)->psz_path );
658                 size_t i_file_size = strlen( &file[0] );
659
660                 strncpy( &path[0], (*p_menu)->psz_path, i_path_size );
661                 strncpy( &path[i_path_size], &file[0], 512 - (i_path_size + i_file_size) );
662                 path[ i_path_size + i_file_size ] = '\0';
663
664                 p_state_current = osd_StateNew( p_this, &path[0], &state[0] );
665             }
666             else /* absolute paths are used. */
667                 p_state_current = osd_StateNew( p_this, &file[0], &state[0] );
668
669             if( !p_state_current || !p_state_current->p_pic )
670                 goto error;
671
672             if( p_state_prev )
673                 p_state_prev->p_next = p_state_current;
674             else
675                 p_current->p_states = p_state_current;
676             p_state_current->p_prev = p_state_prev;
677
678             msg_Dbg( p_this, " |- state=%s, file=%s%s", &state[0], (*p_menu)->psz_path, &file[0] );
679         }
680         p_current->p_current_state = p_current->p_states;
681     }
682
683     /* Find the last button and store its pointer.
684      * The OSD menu behaves like a roundrobin list.
685      */
686     p_current = (*p_menu)->p_button;
687     while( p_current && p_current->p_next )
688     {
689         osd_button_t *p_temp = NULL;
690         p_temp = p_current->p_next;
691         p_current = p_temp;
692     }
693     (*p_menu)->p_last_button = p_current;
694     fclose( fd );
695     return 0;
696
697 #undef MAX_FILE_PATH
698 error:
699     msg_Err( p_this, "parsing file failed (returned %d)", result );
700     fclose( fd );
701     return 1;
702 }
703
704 /*****************************************************************************
705  * osd_ConfigUnload: Load and parse osd text configurationfile
706  *****************************************************************************/
707 void osd_ConfigUnload( vlc_object_t *p_this, osd_menu_t **p_osd)
708 {
709     msg_Dbg( p_this, "unloading OSD menu structure" );
710     osd_MenuFree( p_this, *p_osd );
711 }