4a7e6e78790440d69ca63c41a654bde0addd0c5d
[vlc.git] / modules / misc / lua / vlc.c
1 /*****************************************************************************
2  * vlc.c: Generic lua inteface functions
3  *****************************************************************************
4  * Copyright (C) 2007 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Antoine Cellerier <dionoea at videolan tod org>
8  *          Pierre d'Herbemont <pdherbemont # videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #ifndef  _GNU_SOURCE
29 #   define  _GNU_SOURCE
30 #endif
31
32 #ifdef HAVE_CONFIG_H
33 # include "config.h"
34 #endif
35
36 #include <vlc/vlc.h>
37 #include <vlc_meta.h>
38 #include <vlc_charset.h>
39 #include <vlc_aout.h>
40
41 #include <lua.h>        /* Low level lua C API */
42 #include <lauxlib.h>    /* Higher level C API */
43 #include <lualib.h>     /* Lua libs */
44
45 #include "vlc.h"
46
47 /*****************************************************************************
48  * Module descriptor
49  *****************************************************************************/
50
51 #define INTF_TEXT N_("Lua interface")
52 #define INTF_LONGTEXT N_("Lua interface module to load")
53
54 #define CONFIG_TEXT N_("Lua inteface configuration")
55 #define CONFIG_LONGTEXT N_("Lua interface configuration string. Format is: '[\"<interface module name>\"] = { <option> = <value>, ...}, ...'.")
56
57 vlc_module_begin();
58     add_submodule();
59         add_shortcut( "luameta" );
60         set_shortname( N_( "Lua Meta" ) );
61         set_description( _("Fetch metadata using lua scripts") );
62         set_capability( "meta fetcher", 10 );
63         set_callbacks( E_(FindMeta), NULL );
64     add_submodule();
65         set_shortname( N_( "Lua Art" ) );
66         set_description( _("Fetch artwork using lua scripts") );
67         set_capability( "art finder", 10 );
68         set_callbacks( E_(FindArt), NULL );
69     add_submodule();
70         add_shortcut( "luaplaylist" );
71         set_category( CAT_INPUT );
72         set_subcategory( SUBCAT_INPUT_DEMUX );
73         set_shortname( _("Lua Playlist") );
74         set_description( _("Lua Playlist Parser Interface") );
75         set_capability( "demux2", 2 );
76         set_callbacks( E_(Import_LuaPlaylist), E_(Close_LuaPlaylist) );
77     add_submodule();
78         add_shortcut( "luaintf" );
79         add_shortcut( "luarc" );
80         /* add_shortcut( "rc" ); */
81         add_shortcut( "luahotkeys" );
82         /* add_shortcut( "hotkeys" ); */
83         add_shortcut( "luatelnet" );
84         /* add_shortcut( "telnet" ); */
85         add_shortcut( "luahttp" );
86         /* add_shortcut( "http" ); */
87         set_description( _("Lua Interface Module") );
88         set_capability( "interface", 0 );
89         add_string( "lua-intf", "dummy", NULL,
90                     INTF_TEXT, INTF_LONGTEXT, VLC_FALSE );
91         add_string( "lua-config", "", NULL,
92                     CONFIG_TEXT, CONFIG_LONGTEXT, VLC_FALSE );
93         set_callbacks( E_(Open_LuaIntf), E_(Close_LuaIntf) );
94 vlc_module_end();
95
96 /*****************************************************************************
97  * Internal lua<->vlc utils
98  *****************************************************************************/
99 vlc_object_t * vlclua_get_this( lua_State *L )
100 {
101     vlc_object_t * p_this;
102     lua_getglobal( L, "vlc" );
103     lua_getfield( L, -1, "private" );
104     p_this = (vlc_object_t*)lua_topointer( L, lua_gettop( L ) );
105     lua_pop( L, 2 );
106     return p_this;
107 }
108
109 /*****************************************************************************
110  * VLC error code translation
111  *****************************************************************************/
112 int vlclua_push_ret( lua_State *L, int i_error )
113 {
114     lua_pushnumber( L, i_error );
115     lua_pushstring( L, vlc_error( i_error ) );
116     return 2;
117 }
118
119 /*****************************************************************************
120  * Get the VLC version string
121  *****************************************************************************/
122 int vlclua_version( lua_State *L )
123 {
124     lua_pushstring( L, VLC_Version() );
125     return 1;
126 }
127
128 /*****************************************************************************
129  * Get the VLC copyright
130  *****************************************************************************/
131 int vlclua_copyright( lua_State *L )
132 {
133     lua_pushstring( L, COPYRIGHT_MESSAGE );
134     return 1;
135 }
136
137 /*****************************************************************************
138  * Get the VLC license msg/disclaimer
139  *****************************************************************************/
140 int vlclua_license( lua_State *L )
141 {
142     lua_pushstring( L, LICENSE_MSG );
143     return 1;
144 }
145
146 /*****************************************************************************
147  * Quit VLC
148  *****************************************************************************/
149 int vlclua_quit( lua_State *L )
150 {
151     vlc_object_t *p_this = vlclua_get_this( L );
152     /* The rc.c code also stops the playlist ... not sure if this is needed
153      * though. */
154     vlc_object_kill( p_this->p_libvlc );
155     return 0;
156 }
157
158 /*****************************************************************************
159  * Global properties getters
160  *****************************************************************************/
161 int vlclua_datadir( lua_State *L )
162 {
163     lua_pushstring( L, config_GetDataDir() );
164     return 1;
165 }
166 int vlclua_homedir( lua_State *L )
167 {
168     lua_pushstring( L, vlclua_get_this( L )->p_libvlc->psz_homedir );
169     return 1;
170 }
171 int vlclua_configdir( lua_State *L )
172 {
173     lua_pushstring( L, vlclua_get_this( L )->p_libvlc->psz_configdir );
174     return 1;
175 }
176 int vlclua_cachedir( lua_State *L )
177 {
178     lua_pushstring( L, vlclua_get_this( L )->p_libvlc->psz_cachedir );
179     return 1;
180 }
181 int vlclua_datadir_list( lua_State *L )
182 {
183     const char *psz_dirname = luaL_checkstring( L, 1 );
184     vlc_object_t *p_this = vlclua_get_this( L );
185     char  *ppsz_dir_list[] = { NULL, NULL, NULL, NULL };
186     char **ppsz_dir = ppsz_dir_list;
187     int i = 1;
188
189     if( vlclua_dir_list( p_this, psz_dirname, ppsz_dir_list ) != VLC_SUCCESS )
190         return 0;
191     lua_newtable( L );
192     for( ; *ppsz_dir; ppsz_dir++ )
193     {
194         lua_pushstring( L, *ppsz_dir );
195         lua_rawseti( L, -2, i );
196         i ++;
197     }
198     return 1;
199 }
200
201 /*****************************************************************************
202  * Volume related
203  *****************************************************************************/
204 int vlclua_volume_set( lua_State *L )
205 {
206     vlc_object_t *p_this = vlclua_get_this( L );
207     int i_volume = luaL_checkint( L, 1 );
208     /* Do we need to check that i_volume is in the AOUT_VOLUME_MIN->MAX range?*/
209     return vlclua_push_ret( L, aout_VolumeSet( p_this, i_volume ) );
210 }
211
212 int vlclua_volume_get( lua_State *L )
213 {
214     vlc_object_t *p_this = vlclua_get_this( L );
215     audio_volume_t i_volume;
216     if( aout_VolumeGet( p_this, &i_volume ) == VLC_SUCCESS )
217         lua_pushnumber( L, i_volume );
218     else
219         lua_pushnil( L );
220     return 1;
221 }
222
223 int vlclua_volume_up( lua_State *L )
224 {
225     audio_volume_t i_volume;
226     aout_VolumeUp( vlclua_get_this( L ),
227                    luaL_optint( L, 1, 1 ),
228                    &i_volume );
229     lua_pushnumber( L, i_volume );
230     return 1;
231 }
232
233 int vlclua_volume_down( lua_State *L )
234 {
235     audio_volume_t i_volume;
236     aout_VolumeDown( vlclua_get_this( L ),
237                      luaL_optint( L, 1, 1 ),
238                      &i_volume );
239     lua_pushnumber( L, i_volume );
240     return 1;
241 }
242
243 /*****************************************************************************
244  * Stream handling
245  *****************************************************************************/
246 int vlclua_stream_new( lua_State *L )
247 {
248     vlc_object_t * p_this = vlclua_get_this( L );
249     stream_t * p_stream;
250     const char * psz_url;
251     psz_url = luaL_checkstring( L, -1 );
252     p_stream = stream_UrlNew( p_this, psz_url );
253     if( !p_stream )
254         return luaL_error( L, "Error when opening url: `%s'", psz_url );
255     lua_pushlightuserdata( L, p_stream );
256     return 1;
257 }
258
259 int vlclua_stream_read( lua_State *L )
260 {
261     stream_t * p_stream;
262     int n;
263     byte_t *p_read;
264     int i_read;
265     p_stream = (stream_t *)luaL_checklightuserdata( L, 1 );
266     n = luaL_checkint( L, 2 );
267     p_read = malloc( n );
268     if( !p_read ) return vlclua_error( L );
269     i_read = stream_Read( p_stream, p_read, n );
270     lua_pushlstring( L, (const char *)p_read, i_read );
271     free( p_read );
272     return 1;
273 }
274
275 int vlclua_stream_readline( lua_State *L )
276 {
277     stream_t * p_stream;
278     p_stream = (stream_t *)luaL_checklightuserdata( L, 1 );
279     char *psz_line = stream_ReadLine( p_stream );
280     if( psz_line )
281     {
282         lua_pushstring( L, psz_line );
283         free( psz_line );
284     }
285     else
286         lua_pushnil( L );
287     return 1;
288 }
289
290 int vlclua_stream_delete( lua_State *L )
291 {
292     stream_t * p_stream;
293     p_stream = (stream_t *)luaL_checklightuserdata( L, 1 );
294     stream_Delete( p_stream );
295     return 0;
296 }
297
298 /*****************************************************************************
299  * String transformations
300  *****************************************************************************/
301 int vlclua_decode_uri( lua_State *L )
302 {
303     int i_top = lua_gettop( L );
304     int i;
305     for( i = 1; i <= i_top; i++ )
306     {
307         const char *psz_cstring = luaL_checkstring( L, 1 );
308         char *psz_string = strdup( psz_cstring );
309         lua_remove( L, 1 ); /* remove elements to prevent being limited by
310                              * the stack's size (this function will work with
311                              * up to (stack size - 1) arguments */
312         decode_URI( psz_string );
313         lua_pushstring( L, psz_string );
314         free( psz_string );
315     }
316     return i_top;
317 }
318
319 int vlclua_resolve_xml_special_chars( lua_State *L )
320 {
321     int i_top = lua_gettop( L );
322     int i;
323     for( i = 1; i <= i_top; i++ )
324     {
325         const char *psz_cstring = luaL_checkstring( L, 1 );
326         char *psz_string = strdup( psz_cstring );
327         lua_remove( L, 1 ); /* remove elements to prevent being limited by
328                              * the stack's size (this function will work with
329                              * up to (stack size - 1) arguments */
330         resolve_xml_special_chars( psz_string );
331         lua_pushstring( L, psz_string );
332         free( psz_string );
333     }
334     return i_top;
335 }
336
337 int vlclua_convert_xml_special_chars( lua_State *L )
338 {
339     int i_top = lua_gettop( L );
340     int i;
341     for( i = 1; i <= i_top; i++ )
342     {
343         char *psz_string = convert_xml_special_chars( luaL_checkstring(L,1) );
344         lua_remove( L, 1 );
345         lua_pushstring( L, psz_string );
346         free( psz_string );
347     }
348     return i_top;
349 }
350
351 /*****************************************************************************
352  * Messaging facilities
353  *****************************************************************************/
354 int vlclua_msg_dbg( lua_State *L )
355 {
356     int i_top = lua_gettop( L );
357     vlc_object_t *p_this = vlclua_get_this( L );
358     int i;
359     for( i = 1; i <= i_top; i++ )
360         msg_Dbg( p_this, "%s", luaL_checkstring( L, 1 ) );
361     return 0;
362 }
363 int vlclua_msg_warn( lua_State *L )
364 {
365     int i_top = lua_gettop( L );
366     vlc_object_t *p_this = vlclua_get_this( L );
367     int i;
368     for( i = 1; i <= i_top; i++ )
369         msg_Warn( p_this, "%s", luaL_checkstring( L, i ) );
370     return 0;
371 }
372 int vlclua_msg_err( lua_State *L )
373 {
374     int i_top = lua_gettop( L );
375     vlc_object_t *p_this = vlclua_get_this( L );
376     int i;
377     for( i = 1; i <= i_top; i++ )
378         msg_Err( p_this, "%s", luaL_checkstring( L, i ) );
379     return 0;
380 }
381 int vlclua_msg_info( lua_State *L )
382 {
383     int i_top = lua_gettop( L );
384     vlc_object_t *p_this = vlclua_get_this( L );
385     int i;
386     for( i = 1; i <= i_top; i++ )
387         msg_Info( p_this, "%s", luaL_checkstring( L, i ) );
388     return 0;
389 }
390
391 /*****************************************************************************
392  *
393  *****************************************************************************/
394 static int file_select( const char *file )
395 {
396     int i = strlen( file );
397     return i > 4 && !strcmp( file+i-4, ".lua" );
398 }
399
400 static int file_compare( const char **a, const char **b )
401 {
402     return strcmp( *a, *b );
403 }
404
405 int vlclua_dir_list( vlc_object_t *p_this, const char *luadirname,
406                      char **ppsz_dir_list )
407 {
408     if( asprintf( &ppsz_dir_list[0], "%s" DIR_SEP "lua" DIR_SEP "%s",
409                    p_this->p_libvlc->psz_datadir, luadirname ) < 0 )
410         return VLC_ENOMEM;
411
412 #   if defined(__APPLE__) || defined(SYS_BEOS) || defined(WIN32)
413     {
414         const char *psz_vlcpath = config_GetDataDir();
415         if( asprintf( &ppsz_dir_list[1], "%s" DIR_SEP "lua" DIR_SEP "%s",
416                       psz_vlcpath, luadirname )  < 0 )
417             return VLC_ENOMEM;
418
419         if( asprintf( &ppsz_dir_list[2], "%s" DIR_SEP "share" DIR_SEP "lua" DIR_SEP "%s",
420                       psz_vlcpath, luadirname )  < 0 )
421             return VLC_ENOMEM;
422     }
423 #   else
424     if( asprintf( &ppsz_dir_list[1],
425                   "share" DIR_SEP "lua" DIR_SEP "%s", luadirname ) < 0 )
426         return VLC_ENOMEM;
427
428 #   ifdef HAVE_SYS_STAT_H
429     {
430         struct stat stat_info;
431         if( ( utf8_stat( ppsz_dir_list[1], &stat_info ) == -1 )
432             || !S_ISDIR( stat_info.st_mode ) )
433         {
434             free(ppsz_dir_list[1]);
435             if( asprintf( &ppsz_dir_list[1], "%s" DIR_SEP "lua" DIR_SEP "%s",
436                           config_GetDataDir (), luadirname ) < 0 )
437                 return VLC_ENOMEM;
438         }
439     }
440 #   endif
441 #   endif
442     return VLC_SUCCESS;
443 }
444
445 /*****************************************************************************
446  * Will execute func on all scripts in luadirname, and stop if func returns
447  * success.
448  *****************************************************************************/
449 int vlclua_scripts_batch_execute( vlc_object_t *p_this,
450                                   const char * luadirname,
451                                   int (*func)(vlc_object_t *, const char *, lua_State *, void *),
452                                   lua_State * L,
453                                   void * user_data)
454 {
455     int i_ret = VLC_EGENERIC;
456
457     DIR   *dir           = NULL;
458     char **ppsz_filelist = NULL;
459     char **ppsz_fileend  = NULL;
460     char **ppsz_file;
461
462     char  *ppsz_dir_list[] = { NULL, NULL, NULL, NULL };
463     char **ppsz_dir;
464
465     i_ret = vlclua_dir_list( p_this, luadirname, ppsz_dir_list );
466     if( i_ret != VLC_SUCCESS )
467         return i_ret;
468     i_ret = VLC_EGENERIC;
469
470
471     for( ppsz_dir = ppsz_dir_list; *ppsz_dir; ppsz_dir++ )
472     {
473         int i_files;
474
475         if( ppsz_filelist )
476         {
477             for( ppsz_file = ppsz_filelist; ppsz_file < ppsz_fileend;
478                  ppsz_file++ )
479                 free( *ppsz_file );
480             free( ppsz_filelist );
481             ppsz_filelist = NULL;
482         }
483
484         if( dir )
485         {
486             closedir( dir );
487         }
488
489         msg_Dbg( p_this, "Trying Lua scripts in %s", *ppsz_dir );
490         dir = utf8_opendir( *ppsz_dir );
491
492         if( !dir ) continue;
493         i_files = utf8_loaddir( dir, &ppsz_filelist, file_select,
494                                 file_compare );
495         if( i_files < 1 ) continue;
496         ppsz_fileend = ppsz_filelist + i_files;
497
498         for( ppsz_file = ppsz_filelist; ppsz_file < ppsz_fileend; ppsz_file++ )
499         {
500             char  *psz_filename;
501             if( asprintf( &psz_filename,
502                           "%s" DIR_SEP "%s", *ppsz_dir, *ppsz_file ) < 0)
503                 return VLC_ENOMEM;
504             msg_Dbg( p_this, "Trying Lua playlist script %s", psz_filename );
505
506             i_ret = func( p_this, psz_filename, L, user_data );
507
508             free( psz_filename );
509
510             if( i_ret == VLC_SUCCESS ) break;
511         }
512         if( i_ret == VLC_SUCCESS ) break;
513     }
514
515     if( ppsz_filelist )
516     {
517         for( ppsz_file = ppsz_filelist; ppsz_file < ppsz_fileend;
518              ppsz_file++ )
519             free( *ppsz_file );
520         free( ppsz_filelist );
521     }
522     for( ppsz_dir = ppsz_dir_list; *ppsz_dir; ppsz_dir++ )
523         free( *ppsz_dir );
524
525     if( dir ) closedir( dir );
526
527     return i_ret;
528 }
529
530
531 /*****************************************************************************
532  * Meta data setters utility.
533  * Playlist item table should be on top of the stack when these are called
534  *****************************************************************************/
535 void __vlclua_read_meta_data( vlc_object_t *p_this, lua_State *L,
536                               input_item_t *p_input )
537 {
538 #define TRY_META( a, b )                                        \
539     lua_getfield( L, -1, a );                                   \
540     if( lua_isstring( L, -1 ) )                                 \
541     {                                                           \
542         char *psz_value = strdup( lua_tostring( L, -1 ) );      \
543         EnsureUTF8( psz_value );                                \
544         msg_Dbg( p_this, #b ": %s", psz_value );                \
545         input_item_Set ## b ( p_input, psz_value );             \
546         free( psz_value );                                      \
547     }                                                           \
548     lua_pop( L, 1 ); /* pop a */
549     TRY_META( "title", Title );
550     TRY_META( "artist", Artist );
551     TRY_META( "genre", Genre );
552     TRY_META( "copyright", Copyright );
553     TRY_META( "album", Album );
554     TRY_META( "tracknum", TrackNum );
555     TRY_META( "description", Description );
556     TRY_META( "rating", Rating );
557     TRY_META( "date", Date );
558     TRY_META( "setting", Setting );
559     TRY_META( "url", URL );
560     TRY_META( "language", Language );
561     TRY_META( "nowplaying", NowPlaying );
562     TRY_META( "publisher", Publisher );
563     TRY_META( "encodedby", EncodedBy );
564     TRY_META( "arturl", ArtURL );
565     TRY_META( "trackid", TrackID );
566 }
567
568 void __vlclua_read_custom_meta_data( vlc_object_t *p_this, lua_State *L,
569                                      input_item_t *p_input )
570 {
571     /* ... item */
572     lua_getfield( L, -1, "meta" );
573     /* ... item meta */
574     if( lua_istable( L, -1 ) )
575     {
576         lua_pushnil( L );
577         /* ... item meta nil */
578         while( lua_next( L, -2 ) )
579         {
580             /* ... item meta key value */
581             if( !lua_isstring( L, -2 ) )
582             {
583                 msg_Warn( p_this, "Custom meta data category name must be "
584                                    "a string" );
585             }
586             else if( !lua_istable( L, -1 ) )
587             {
588                 msg_Warn( p_this, "Custom meta data category contents "
589                                    "must be a table" );
590             }
591             else
592             {
593                 const char *psz_meta_category = lua_tostring( L, -2 );
594                 msg_Dbg( p_this, "Found custom meta data category: %s",
595                          psz_meta_category );
596                 lua_pushnil( L );
597                 /* ... item meta key value nil */
598                 while( lua_next( L, -2 ) )
599                 {
600                     /* ... item meta key value key2 value2 */
601                     if( !lua_isstring( L, -2 ) )
602                     {
603                         msg_Warn( p_this, "Custom meta category item name "
604                                            "must be a string." );
605                     }
606                     else if( !lua_isstring( L, -1 ) )
607                     {
608                         msg_Warn( p_this, "Custom meta category item value "
609                                            "must be a string." );
610                     }
611                     else
612                     {
613                         const char *psz_meta_name =
614                             lua_tostring( L, -2 );
615                         const char *psz_meta_value =
616                             lua_tostring( L, -1 );
617                         msg_Dbg( p_this, "Custom meta %s, %s: %s",
618                                  psz_meta_category, psz_meta_name,
619                                  psz_meta_value );
620                         input_ItemAddInfo( p_input, psz_meta_category,
621                                            psz_meta_name, psz_meta_value );
622                     }
623                     lua_pop( L, 1 ); /* pop item */
624                     /* ... item meta key value key2 */
625                 }
626                 /* ... item meta key value */
627             }
628             lua_pop( L, 1 ); /* pop category */
629             /* ... item meta key */
630         }
631         /* ... item meta */
632     }
633     lua_pop( L, 1 ); /* pop "meta" */
634     /* ... item -> back to original stack */
635 }
636
637 /*****************************************************************************
638  * Playlist utilities
639  ****************************************************************************/
640 /**
641  * Playlist item table should be on top of the stack when this is called
642  */
643 void __vlclua_read_options( vlc_object_t *p_this, lua_State *L,
644                             int *pi_options, char ***pppsz_options )
645 {
646     lua_getfield( L, -1, "options" );
647     if( lua_istable( L, -1 ) )
648     {
649         lua_pushnil( L );
650         while( lua_next( L, -2 ) )
651         {
652             if( lua_isstring( L, -1 ) )
653             {
654                 char *psz_option = strdup( lua_tostring( L, -1 ) );
655                 msg_Dbg( p_this, "Option: %s", psz_option );
656                 INSERT_ELEM( *pppsz_options, *pi_options, *pi_options,
657                              psz_option );
658             }
659             else
660             {
661                 msg_Warn( p_this, "Option should be a string" );
662             }
663             lua_pop( L, 1 ); /* pop option */
664         }
665     }
666     lua_pop( L, 1 ); /* pop "options" */
667 }
668
669 int __vlclua_playlist_add_internal( vlc_object_t *p_this, lua_State *L,
670                                     playlist_t *p_playlist,
671                                     input_item_t *p_parent, vlc_bool_t b_play )
672 {
673     int i_count = 0;
674
675     /* playlist */
676     if( lua_istable( L, -1 ) )
677     {
678         lua_pushnil( L );
679         /* playlist nil */
680         while( lua_next( L, -2 ) )
681         {
682             /* playlist key item */
683             /* <Parse playlist item> */
684             if( lua_istable( L, -1 ) )
685             {
686                 lua_getfield( L, -1, "path" );
687                 /* playlist key item path */
688                 if( lua_isstring( L, -1 ) )
689                 {
690                     const char   *psz_path     = NULL;
691                     const char   *psz_name     = NULL;
692                     char        **ppsz_options = NULL;
693                     int           i_options    = 0;
694                     mtime_t       i_duration   = -1;
695                     input_item_t *p_input;
696
697                     /* Read path and name */
698                     psz_path = lua_tostring( L, -1 );
699                     msg_Dbg( p_this, "Path: %s", psz_path );
700                     lua_getfield( L, -2, "name" );
701                     /* playlist key item path name */
702                     if( lua_isstring( L, -1 ) )
703                     {
704                         psz_name = lua_tostring( L, -1 );
705                         msg_Dbg( p_this, "Name: %s", psz_name );
706                     }
707                     else
708                     {
709                         if( !lua_isnil( L, -1 ) )
710                             msg_Warn( p_this, "Playlist item name should be a string." );
711                         psz_name = psz_path;
712                     }
713
714                     /* Read duration */
715                     lua_getfield( L, -3, "duration" );
716                     /* playlist key item path name duration */
717                     if( lua_isnumber( L, -1 ) )
718                     {
719                         i_duration = (mtime_t)(lua_tonumber( L, -1 )*1e6);
720                     }
721                     else if( !lua_isnil( L, -1 ) )
722                     {
723                         msg_Warn( p_this, "Playlist item duration should be a number (in seconds)." );
724                     }
725                     lua_pop( L, 1 ); /* pop "duration" */
726
727                     /* playlist key item path name */
728
729                     /* Read options: item must be on top of stack */
730                     lua_pushvalue( L, -3 );
731                     /* playlist key item path name item */
732                     vlclua_read_options( p_this, L, &i_options, &ppsz_options );
733
734                     /* Create input item */
735                     p_input = input_ItemNewExt( p_playlist, psz_path,
736                                                 psz_name, i_options,
737                                                 (const char **)ppsz_options,
738                                                 i_duration );
739                     lua_pop( L, 3 ); /* pop "path name item" */
740                     /* playlist key item */
741
742                     /* Read meta data: item must be on top of stack */
743                     vlclua_read_meta_data( p_this, L, p_input );
744
745                     /* Read custom meta data: item must be on top of stack*/
746                     vlclua_read_custom_meta_data( p_this, L, p_input );
747
748                     /* Append item to playlist */
749                     if( p_parent ) /* Add to node */
750                         input_ItemAddSubItem( p_parent, p_input );
751                     else /* Play or Enqueue (preparse) */
752                         /* FIXME: playlist_AddInput() can fail */
753                         playlist_AddInput( p_playlist, p_input,
754                                PLAYLIST_APPEND | 
755                                ( b_play ? PLAYLIST_GO : PLAYLIST_PREPARSE ),
756                                PLAYLIST_END, VLC_TRUE, VLC_FALSE );
757                     i_count ++; /* increment counter */
758                     vlc_gc_decref( p_input );
759                     while( i_options > 0 )
760                         free( ppsz_options[--i_options] );
761                     free( ppsz_options );
762                 }
763                 else
764                 {
765                     lua_pop( L, 1 ); /* pop "path" */
766                     msg_Warn( p_this,
767                              "Playlist item's path should be a string" );
768                 }
769                 /* playlist key item */
770             }
771             else
772             {
773                 msg_Warn( p_this, "Playlist item should be a table" );
774             }
775             /* <Parse playlist item> */
776             lua_pop( L, 1 ); /* pop the value, keep the key for
777                               * the next lua_next() call */
778             /* playlist key */
779         }
780         /* playlist */
781     }
782     else
783     {
784         msg_Warn( p_this, "Playlist should be a table." );
785     }
786     return i_count;
787 }