git.sesse.net Git - vlc/blob - modules/misc/lua/extension.c

   1 /*****************************************************************************
   2  * extension.c: Lua Extensions (meta data, web information, ...)
   3  *****************************************************************************
   4  * Copyright (C) 2009-2010 VideoLAN and authors
   5  * $Id$
   6  *
   7  * Authors: Jean-Philippe André < jpeg # videolan.org >
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #include "vlc.h"
  25 #include "libs.h"
  26 #include "extension.h"
  27 #include "assert.h"
  28
  29 #include <vlc_input.h>
  30 #include <vlc_events.h>
  31
  32 /* Functions to register */
  33 static const luaL_Reg p_reg[] =
  34 {
  35     { NULL, NULL }
  36 };
  37
  38 /*
  39  * Extensions capabilities
  40  * Note: #define and ppsz_capabilities must be in sync
  41  */
  42 #define EXT_HAS_MENU          (1 << 0)   ///< Hook: menu
  43 #define EXT_TRIGGER_ONLY      (1 << 1)   ///< Hook: trigger. Not activable
  44 #define EXT_INPUT_LISTENER    (1 << 2)   ///< Hook: input_changed
  45 #define EXT_META_LISTENER     (1 << 3)   ///< Hook: meta_changed
  46 #define EXT_PLAYING_LISTENER  (1 << 4)   ///< Hook: status_changed
  47
  48 const char* const ppsz_capabilities[] = {
  49     "menu",
  50     "trigger",
  51     "input-listener",
  52     "meta-listener",
  53     "playing-listener",
  54     NULL
  55 };
  56
  57 static int ScanExtensions( extensions_manager_t *p_this );
  58 static int ScanLuaCallback( vlc_object_t *p_this, const char *psz_script,
  59                             void *dummy );
  60 static int Control( extensions_manager_t *, int, va_list );
  61 static int GetMenuEntries( extensions_manager_t *p_mgr, extension_t *p_ext,
  62                     char ***pppsz_titles, uint16_t **ppi_ids );
  63 static lua_State* GetLuaState( extensions_manager_t *p_mgr,
  64                                extension_t *p_ext );
  65 static int TriggerMenu( extension_t *p_ext, int id );
  66 static int TriggerExtension( extensions_manager_t *p_mgr,
  67                              extension_t *p_ext );
  68
  69 int vlclua_extension_deactivate( lua_State *L );
  70
  71 /* Interactions */
  72 static int vlclua_extension_dialog_callback( vlc_object_t *p_this,
  73                                              char const *psz_var,
  74                                              vlc_value_t oldval,
  75                                              vlc_value_t newval,
  76                                              void *p_data );
  77
  78 /* Input item callback: vlc_InputItemMetaChanged */
  79 static void inputItemMetaChanged( const vlc_event_t *p_event,
  80                                   void *data );
  81
  82
  83 /**
  84  * Module entry-point
  85  **/
  86 int Open_Extension( vlc_object_t *p_this )
  87 {
  88     msg_Dbg( p_this, "Opening EXPERIMENTAL Lua Extension module" );
  89
  90     extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
  91
  92     p_mgr->pf_control = Control;
  93
  94     extensions_manager_sys_t *p_sys = ( extensions_manager_sys_t* )
  95                     calloc( 1, sizeof( extensions_manager_sys_t ) );
  96     if( !p_sys ) return VLC_ENOMEM;
  97
  98     p_mgr->p_sys = p_sys;
  99     ARRAY_INIT( p_sys->activated_extensions );
 100     ARRAY_INIT( p_mgr->extensions );
 101     vlc_mutex_init( &p_mgr->lock );
 102     vlc_mutex_init( &p_mgr->p_sys->lock );
 103
 104     /* Scan available Lua Extensions */
 105     if( ScanExtensions( p_mgr ) != VLC_SUCCESS )
 106     {
 107         msg_Err( p_mgr, "Can't load extensions modules" );
 108         return VLC_EGENERIC;
 109     }
 110
 111     // Create the dialog-event variable
 112     var_Create( p_this, "dialog-event", VLC_VAR_ADDRESS );
 113     var_AddCallback( p_this, "dialog-event",
 114                      vlclua_extension_dialog_callback, NULL );
 115
 116     return VLC_SUCCESS;
 117 }
 118
 119 /**
 120  * Module unload function
 121  **/
 122 void Close_Extension( vlc_object_t *p_this )
 123 {
 124     extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
 125     msg_Dbg( p_mgr, "Deactivating all loaded extensions" );
 126
 127     vlc_mutex_lock( &p_mgr->lock );
 128     p_mgr->p_sys->b_killed = true;
 129     vlc_mutex_unlock( &p_mgr->lock );
 130
 131     var_Destroy( p_mgr, "dialog-event" );
 132
 133     extension_t *p_ext = NULL;
 134     FOREACH_ARRAY( p_ext, p_mgr->p_sys->activated_extensions )
 135     {
 136         if( !p_ext ) break;
 137         msg_Dbg( p_mgr, "Deactivating '%s'", p_ext->psz_title );
 138         Deactivate( p_mgr, p_ext );
 139         WaitForDeactivation( p_ext );
 140     }
 141     FOREACH_END()
 142
 143     msg_Dbg( p_mgr, "All extensions are now deactivated" );
 144     ARRAY_RESET( p_mgr->p_sys->activated_extensions );
 145
 146     vlc_mutex_destroy( &p_mgr->lock );
 147     vlc_mutex_destroy( &p_mgr->p_sys->lock );
 148     free( p_mgr->p_sys );
 149     p_mgr->p_sys = NULL;
 150
 151     /* Free extensions' memory */
 152     FOREACH_ARRAY( p_ext, p_mgr->extensions )
 153     {
 154         if( !p_ext )
 155             break;
 156         if( p_ext->p_sys->L )
 157             lua_close( p_ext->p_sys->L );
 158         free( p_ext->psz_name );
 159         free( p_ext->psz_title );
 160         free( p_ext->psz_author );
 161         free( p_ext->psz_description );
 162         free( p_ext->psz_shortdescription );
 163         free( p_ext->psz_url );
 164         free( p_ext->psz_version );
 165
 166         vlc_mutex_destroy( &p_ext->p_sys->running_lock );
 167         vlc_mutex_destroy( &p_ext->p_sys->command_lock );
 168         vlc_cond_destroy( &p_ext->p_sys->wait );
 169
 170         free( p_ext->p_sys );
 171         free( p_ext );
 172     }
 173     FOREACH_END()
 174
 175     ARRAY_RESET( p_mgr->extensions );
 176 }
 177
 178 /**
 179  * Batch scan all Lua files in folder "extensions"
 180  * @param p_mgr This extensions_manager_t object
 181  **/
 182 static int ScanExtensions( extensions_manager_t *p_mgr )
 183 {
 184     int i_ret =
 185         vlclua_scripts_batch_execute( VLC_OBJECT( p_mgr ),
 186                                       "extensions",
 187                                       &ScanLuaCallback,
 188                                       NULL );
 189
 190     if( !i_ret )
 191         return VLC_EGENERIC;
 192
 193     return VLC_SUCCESS;
 194 }
 195
 196 /**
 197  * Dummy Lua function: does nothing
 198  * @note This function can be used to replace "require" while scanning for
 199  * extensions
 200  * Even the built-in libraries are not loaded when calling descriptor()
 201  **/
 202 static int vlclua_dummy_require( lua_State *L )
 203 {
 204     (void) L;
 205     return 0;
 206 }
 207
 208 /**
 209  * Batch scan all Lua files in folder "extensions": callback
 210  * @param p_this This extensions_manager_t object
 211  * @param psz_script Name of the script to run
 212  * @param L Lua State, common to all scripts here
 213  * @param dummy: unused
 214  **/
 215 int ScanLuaCallback( vlc_object_t *p_this, const char *psz_script,
 216                      void *dummy )
 217 {
 218     VLC_UNUSED(dummy);
 219     extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
 220     bool b_ok = false;
 221
 222     msg_Dbg( p_mgr, "Scanning Lua script %s", psz_script );
 223
 224     vlc_mutex_lock( &p_mgr->lock );
 225
 226     /* Create new script descriptor */
 227     extension_t *p_ext = ( extension_t* ) calloc( 1, sizeof( extension_t ) );
 228     if( !p_ext )
 229     {
 230         vlc_mutex_unlock( &p_mgr->lock );
 231         return 0;
 232     }
 233
 234     p_ext->psz_name = strdup( psz_script );
 235     p_ext->p_sys = (extension_sys_t*) calloc( 1, sizeof( extension_sys_t ) );
 236     if( !p_ext->p_sys || !p_ext->psz_name )
 237     {
 238         free( p_ext->psz_name );
 239         free( p_ext->p_sys );
 240         free( p_ext );
 241         vlc_mutex_unlock( &p_mgr->lock );
 242         return 0;
 243     }
 244     p_ext->p_sys->p_mgr = p_mgr;
 245
 246     /* Mutexes and conditions */
 247     vlc_mutex_init( &p_ext->p_sys->command_lock );
 248     vlc_mutex_init( &p_ext->p_sys->running_lock );
 249     vlc_cond_init( &p_ext->p_sys->wait );
 250
 251     /* Prepare Lua state */
 252     lua_State *L = luaL_newstate();
 253     lua_register( L, "require", &vlclua_dummy_require );
 254
 255     /* Let's run it */
 256     if( luaL_dofile( L, psz_script ) )
 257     {
 258         msg_Warn( p_mgr, "Error loading script %s: %s", psz_script,
 259                   lua_tostring( L, lua_gettop( L ) ) );
 260         lua_pop( L, 1 );
 261         goto exit;
 262     }
 263
 264     /* Scan script for capabilities */
 265     lua_getglobal( L, "descriptor" );
 266
 267     if( !lua_isfunction( L, -1 ) )
 268     {
 269         msg_Warn( p_mgr, "Error while running script %s, "
 270                   "function descriptor() not found", psz_script );
 271         goto exit;
 272     }
 273
 274     if( lua_pcall( L, 0, 1, 0 ) )
 275     {
 276         msg_Warn( p_mgr, "Error while running script %s, "
 277                   "function descriptor(): %s", psz_script,
 278                   lua_tostring( L, lua_gettop( L ) ) );
 279         goto exit;
 280     }
 281
 282     if( lua_gettop( L ) )
 283     {
 284         if( lua_istable( L, -1 ) )
 285         {
 286             /* Get caps */
 287             lua_getfield( L, -1, "capabilities" );
 288             if( lua_istable( L, -1 ) )
 289             {
 290                 lua_pushnil( L );
 291                 while( lua_next( L, -2 ) != 0 )
 292                 {
 293                     /* Key is at index -2 and value at index -1. Discard key */
 294                     const char *psz_cap = luaL_checkstring( L, -1 );
 295                     int i_cap = 0;
 296                     bool b_ok = false;
 297                     /* Find this capability's flag */
 298                     for( const char *iter = *ppsz_capabilities;
 299                          iter != NULL;
 300                          iter = ppsz_capabilities[ ++i_cap ])
 301                     {
 302                         if( !strcmp( iter, psz_cap ) )
 303                         {
 304                             /* Flag it! */
 305                             p_ext->p_sys->i_capabilities |= 1 << i_cap;
 306                             b_ok = true;
 307                             break;
 308                         }
 309                     }
 310                     if( !b_ok )
 311                     {
 312                         msg_Warn( p_mgr, "Extension capability '%s' unknown in"
 313                                   " script %s", psz_cap, psz_script );
 314                     }
 315                     /* Removes 'value'; keeps 'key' for next iteration */
 316                     lua_pop( L, 1 );
 317                 }
 318             }
 319             else
 320             {
 321                 msg_Warn( p_mgr, "In script %s, function descriptor() "
 322                               "did not return a table of capabilities.",
 323                               psz_script );
 324             }
 325             lua_pop( L, 1 );
 326
 327             /* Get title */
 328             lua_getfield( L, -1, "title" );
 329             if( lua_isstring( L, -1 ) )
 330             {
 331                 p_ext->psz_title = strdup( luaL_checkstring( L, -1 ) );
 332             }
 333             else
 334             {
 335                 msg_Dbg( p_mgr, "In script %s, function descriptor() "
 336                                 "did not return a string as title.",
 337                                 psz_script );
 338                 p_ext->psz_title = strdup( psz_script );
 339             }
 340             lua_pop( L, 1 );
 341
 342             /* Get author */
 343             lua_getfield( L, -1, "author" );
 344             p_ext->psz_author = luaL_strdupornull( L, -1 );
 345             lua_pop( L, 1 );
 346
 347             /* Get description */
 348             lua_getfield( L, -1, "description" );
 349             p_ext->psz_description = luaL_strdupornull( L, -1 );
 350             lua_pop( L, 1 );
 351
 352             /* Get short description */
 353             lua_getfield( L, -1, "shortdesc" );
 354             p_ext->psz_shortdescription = luaL_strdupornull( L, -1 );
 355             lua_pop( L, 1 );
 356
 357             /* Get URL */
 358             lua_getfield( L, -1, "url" );
 359             p_ext->psz_url = luaL_strdupornull( L, -1 );
 360             lua_pop( L, 1 );
 361
 362             /* Get version */
 363             lua_getfield( L, -1, "version" );
 364             p_ext->psz_version = luaL_strdupornull( L, -1 );
 365             lua_pop( L, 1 );
 366         }
 367         else
 368         {
 369             msg_Warn( p_mgr, "In script %s, function descriptor() "
 370                       "did not return a table!", psz_script );
 371             goto exit;
 372         }
 373     }
 374     else
 375     {
 376         msg_Err( p_mgr, "Script %s went completely foobar", psz_script );
 377         goto exit;
 378     }
 379
 380     msg_Dbg( p_mgr, "Script %s has the following capability flags: 0x%x",
 381              psz_script, p_ext->p_sys->i_capabilities );
 382
 383     b_ok = true;
 384 exit:
 385     lua_close( L );
 386     if( !b_ok )
 387     {
 388         free( p_ext->psz_name );
 389         free( p_ext->psz_title );
 390         free( p_ext->psz_url );
 391         free( p_ext->psz_author );
 392         free( p_ext->psz_description );
 393         free( p_ext->psz_shortdescription );
 394         free( p_ext->psz_version );
 395         vlc_mutex_destroy( &p_ext->p_sys->command_lock );
 396         vlc_mutex_destroy( &p_ext->p_sys->running_lock );
 397         vlc_cond_destroy( &p_ext->p_sys->wait );
 398         free( p_ext->p_sys );
 399         free( p_ext );
 400     }
 401     else
 402     {
 403         /* Add the extension to the list of known extensions */
 404         ARRAY_APPEND( p_mgr->extensions, p_ext );
 405     }
 406
 407     vlc_mutex_unlock( &p_mgr->lock );
 408     /* Continue batch execution */
 409     return VLC_EGENERIC;
 410 }
 411
 412 static int Control( extensions_manager_t *p_mgr, int i_control, va_list args )
 413 {
 414     extension_t *p_ext = NULL;
 415     bool *pb = NULL;
 416     uint16_t **ppus = NULL;
 417     char ***pppsz = NULL;
 418     int i = 0;
 419
 420     switch( i_control )
 421     {
 422         case EXTENSION_ACTIVATE:
 423             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 424             return Activate( p_mgr, p_ext );
 425
 426         case EXTENSION_DEACTIVATE:
 427             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 428             return Deactivate( p_mgr, p_ext );
 429
 430         case EXTENSION_IS_ACTIVATED:
 431             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 432             pb = ( bool* ) va_arg( args, bool* );
 433             *pb = IsActivated( p_mgr, p_ext );
 434             break;
 435
 436         case EXTENSION_HAS_MENU:
 437             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 438             pb = ( bool* ) va_arg( args, bool* );
 439             *pb = ( p_ext->p_sys->i_capabilities & EXT_HAS_MENU ) ? 1 : 0;
 440             break;
 441
 442         case EXTENSION_GET_MENU:
 443             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 444             pppsz = ( char*** ) va_arg( args, char*** );
 445             ppus = ( uint16_t** ) va_arg( args, uint16_t** );
 446             return GetMenuEntries( p_mgr, p_ext, pppsz, ppus );
 447
 448         case EXTENSION_TRIGGER_ONLY:
 449             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 450             pb = ( bool* ) va_arg( args, bool* );
 451             *pb = ( p_ext->p_sys->i_capabilities & EXT_TRIGGER_ONLY ) ? 1 : 0;
 452             break;
 453
 454         case EXTENSION_TRIGGER:
 455             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 456             return TriggerExtension( p_mgr, p_ext );
 457
 458         case EXTENSION_TRIGGER_MENU:
 459             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 460             // GCC: 'uint16_t' is promoted to 'int' when passed through '...'
 461             i = ( int ) va_arg( args, int );
 462             return TriggerMenu( p_ext, i );
 463
 464         case EXTENSION_SET_INPUT:
 465         {
 466             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 467             input_thread_t *p_input = va_arg( args, struct input_thread_t * );
 468
 469             if( !LockExtension( p_ext ) )
 470                 return VLC_EGENERIC;
 471
 472             // Change input
 473             input_thread_t *old = p_ext->p_sys->p_input;
 474             input_item_t *p_item;
 475             if( old )
 476             {
 477                 // Untrack meta fetched events
 478                 if( p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
 479                 {
 480                     p_item = input_GetItem( old );
 481                     vlc_event_detach( &p_item->event_manager,
 482                                       vlc_InputItemMetaChanged,
 483                                       inputItemMetaChanged,
 484                                       p_ext );
 485                     vlc_gc_decref( p_item );
 486                 }
 487                 vlc_object_release( old );
 488             }
 489
 490             p_ext->p_sys->p_input = p_input ? vlc_object_hold( p_input )
 491                                             : p_input;
 492
 493             // Tell the script the input changed
 494             if( p_ext->p_sys->i_capabilities & EXT_INPUT_LISTENER )
 495             {
 496                 PushCommandUnique( p_ext, CMD_SET_INPUT );
 497             }
 498
 499             // Track meta fetched events
 500             if( p_ext->p_sys->p_input &&
 501                 p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
 502             {
 503                 p_item = input_GetItem( p_ext->p_sys->p_input );
 504                 vlc_gc_incref( p_item );
 505                 vlc_event_attach( &p_item->event_manager,
 506                                   vlc_InputItemMetaChanged,
 507                                   inputItemMetaChanged,
 508                                   p_ext );
 509             }
 510
 511             UnlockExtension( p_ext );
 512             break;
 513         }
 514         case EXTENSION_PLAYING_CHANGED:
 515         {
 516             extension_t *p_ext;
 517             p_ext = ( extension_t* ) va_arg( args, extension_t* );
 518             assert( p_ext->psz_name != NULL );
 519             i = ( int ) va_arg( args, int );
 520             if( p_ext->p_sys->i_capabilities & EXT_PLAYING_LISTENER )
 521             {
 522                 PushCommand( p_ext, CMD_PLAYING_CHANGED, i );
 523             }
 524             break;
 525         }
 526         default:
 527             msg_Warn( p_mgr, "Control '%d' not yet implemented in Extension",
 528                       i_control );
 529             return VLC_EGENERIC;
 530     }
 531
 532     return VLC_SUCCESS;
 533 }
 534
 535 int lua_ExtensionActivate( extensions_manager_t *p_mgr, extension_t *p_ext )
 536 {
 537     assert( p_mgr != NULL && p_ext != NULL );
 538     return lua_ExecuteFunction( p_mgr, p_ext, "activate", LUA_END );
 539 }
 540
 541 int lua_ExtensionDeactivate( extensions_manager_t *p_mgr, extension_t *p_ext )
 542 {
 543     assert( p_mgr != NULL && p_ext != NULL );
 544
 545     if( !p_ext->p_sys->L )
 546         return VLC_SUCCESS;
 547
 548     // Unset and release input objects
 549     if( p_ext->p_sys->p_input )
 550     {
 551         if( p_ext->p_sys->i_capabilities & EXT_META_LISTENER )
 552         {
 553             // Release item
 554             input_item_t *p_item = input_GetItem( p_ext->p_sys->p_input );
 555             vlc_gc_decref( p_item );
 556         }
 557         vlc_object_release( p_ext->p_sys->p_input );
 558     }
 559
 560     int i_ret = lua_ExecuteFunction( p_mgr, p_ext, "deactivate", LUA_END );
 561
 562     /* Clear Lua State */
 563     lua_close( p_ext->p_sys->L );
 564     p_ext->p_sys->L = NULL;
 565
 566     return i_ret;
 567 }
 568
 569 int lua_ExtensionWidgetClick( extensions_manager_t *p_mgr,
 570                               extension_t *p_ext,
 571                               extension_widget_t *p_widget )
 572 {
 573     if( !p_ext->p_sys->L )
 574         return VLC_SUCCESS;
 575
 576     lua_State *L = GetLuaState( p_mgr, p_ext );
 577     lua_pushlightuserdata( L, p_widget );
 578     lua_gettable( L, LUA_REGISTRYINDEX );
 579     return lua_ExecuteFunction( p_mgr, p_ext, NULL, LUA_END );
 580 }
 581
 582
 583 /**
 584  * Get the list of menu entries from an extension script
 585  * @param p_mgr
 586  * @param p_ext
 587  * @param pppsz_titles Pointer to NULL. All strings must be freed by the caller
 588  * @param ppi_ids Pointer to NULL. Must be freed by the caller.
 589  * @note This function is allowed to run in the UI thread. This means
 590  *       that it MUST respond very fast.
 591  * @todo Remove the menu() hook and provide a new function vlc.set_menu()
 592  **/
 593 static int GetMenuEntries( extensions_manager_t *p_mgr, extension_t *p_ext,
 594                     char ***pppsz_titles, uint16_t **ppi_ids )
 595 {
 596     assert( *pppsz_titles == NULL );
 597     assert( *ppi_ids == NULL );
 598
 599     if( !IsActivated( p_mgr, p_ext ) )
 600     {
 601         msg_Dbg( p_mgr, "Can't get menu before activating the extension!" );
 602         return VLC_EGENERIC;
 603     }
 604
 605     if( !LockExtension( p_ext ) )
 606     {
 607         /* Dying extension, fail. */
 608         return VLC_EGENERIC;
 609     }
 610
 611     int i_ret = VLC_EGENERIC;
 612     lua_State *L = GetLuaState( p_mgr, p_ext );
 613
 614     if( ( p_ext->p_sys->i_capabilities & EXT_HAS_MENU ) == 0 )
 615     {
 616         msg_Dbg( p_mgr, "can't get a menu from an extension without menu!" );
 617         goto exit;
 618     }
 619
 620     lua_getglobal( L, "menu" );
 621
 622     if( !lua_isfunction( L, -1 ) )
 623     {
 624         msg_Warn( p_mgr, "Error while running script %s, "
 625                   "function menu() not found", p_ext->psz_name );
 626         goto exit;
 627     }
 628
 629     if( lua_pcall( L, 0, 1, 0 ) )
 630     {
 631         msg_Warn( p_mgr, "Error while running script %s, "
 632                   "function menu(): %s", p_ext->psz_name,
 633                   lua_tostring( L, lua_gettop( L ) ) );
 634         goto exit;
 635     }
 636
 637     if( lua_gettop( L ) )
 638     {
 639         if( lua_istable( L, -1 ) )
 640         {
 641             /* Get table size */
 642             size_t i_size = lua_objlen( L, -1 );
 643             *pppsz_titles = ( char** ) calloc( i_size+1, sizeof( char* ) );
 644             *ppi_ids = ( uint16_t* ) calloc( i_size+1, sizeof( uint16_t ) );
 645
 646             /* Walk table */
 647             size_t i_idx = 0;
 648             lua_pushnil( L );
 649             while( lua_next( L, -2 ) != 0 )
 650             {
 651                 assert( i_idx < i_size );
 652                 if( (!lua_isstring( L, -1 )) || (!lua_isnumber( L, -2 )) )
 653                 {
 654                     msg_Warn( p_mgr, "In script %s, an entry in "
 655                               "the menu table is invalid!", p_ext->psz_name );
 656                     goto exit;
 657                 }
 658                 (*pppsz_titles)[ i_idx ] = strdup( luaL_checkstring( L, -1 ) );
 659                 (*ppi_ids)[ i_idx ] = (uint16_t) ( luaL_checkinteger( L, -2 ) & 0xFFFF );
 660                 i_idx++;
 661                 lua_pop( L, 1 );
 662             }
 663         }
 664         else
 665         {
 666             msg_Warn( p_mgr, "Function menu() in script %s "
 667                       "did not return a table", p_ext->psz_name );
 668             goto exit;
 669         }
 670     }
 671     else
 672     {
 673         msg_Warn( p_mgr, "Script %s went completely foobar", p_ext->psz_name );
 674         goto exit;
 675     }
 676
 677     i_ret = VLC_SUCCESS;
 678
 679 exit:
 680     UnlockExtension( p_ext );
 681     if( i_ret != VLC_SUCCESS )
 682     {
 683         msg_Dbg( p_mgr, "Something went wrong in %s (%s:%d)",
 684                  __func__, __FILE__, __LINE__ );
 685     }
 686     return i_ret;
 687 }
 688
 689 /* Must be entered with the Lock on Extension */
 690 static lua_State* GetLuaState( extensions_manager_t *p_mgr,
 691                                extension_t *p_ext )
 692 {
 693     lua_State *L = NULL;
 694     if( p_ext )
 695         L = p_ext->p_sys->L;
 696
 697     if( !L )
 698     {
 699         L = luaL_newstate();
 700         if( !L )
 701         {
 702             msg_Err( p_mgr, "Could not create new Lua State" );
 703             return NULL;
 704         }
 705         vlclua_set_this( L, p_mgr );
 706         vlclua_extension_set( L, p_ext );
 707
 708         luaL_openlibs( L );
 709         luaL_register( L, "vlc", p_reg );
 710         luaopen_msg( L );
 711
 712         if( p_ext )
 713         {
 714             /* Load more libraries */
 715             luaopen_acl( L );
 716             luaopen_config( L );
 717             luaopen_dialog( L, p_ext );
 718             luaopen_input( L );
 719             luaopen_md5( L );
 720             luaopen_msg( L );
 721             luaopen_misc( L );
 722             luaopen_net( L );
 723             luaopen_object( L );
 724             luaopen_osd( L );
 725             luaopen_playlist( L );
 726             luaopen_sd( L );
 727             luaopen_stream( L );
 728             luaopen_strings( L );
 729             luaopen_variables( L );
 730             luaopen_video( L );
 731             luaopen_vlm( L );
 732             luaopen_volume( L );
 733             luaopen_xml( L );
 734
 735             /* Register extension specific functions */
 736             lua_getglobal( L, "vlc" );
 737             lua_pushcfunction( L, vlclua_extension_deactivate );
 738             lua_setfield( L, -2, "deactivate" );
 739
 740             /* Setup the module search path */
 741             if( vlclua_add_modules_path( p_mgr, L, p_ext->psz_name ) )
 742             {
 743                 msg_Warn( p_mgr, "Error while setting the module search path for %s", p_ext->psz_name );
 744                 return NULL;
 745             }
 746
 747             /* Load and run the script(s) */
 748             if( luaL_dofile( L, p_ext->psz_name ) != 0 )
 749             {
 750                 msg_Warn( p_mgr, "Error loading script %s: %s", p_ext->psz_name,
 751                           lua_tostring( L, lua_gettop( L ) ) );
 752                 lua_pop( L, 1 );
 753                 return NULL;
 754             }
 755
 756             p_ext->p_sys->L = L;
 757         }
 758     }
 759
 760     return L;
 761 }
 762
 763 int lua_ExecuteFunction( extensions_manager_t *p_mgr, extension_t *p_ext,
 764                             const char *psz_function, ... )
 765 {
 766     va_list args;
 767     va_start( args, psz_function );
 768     int i_ret = lua_ExecuteFunctionVa( p_mgr, p_ext, psz_function, args );
 769     va_end( args );
 770     return i_ret;
 771 }
 772
 773 /**
 774  * Execute a function in a Lua script
 775  * @param psz_function Name of global function to execute. If NULL, assume
 776  *                     that the function object is already on top of the
 777  *                     stack.
 778  * @return < 0 in case of failure, >= 0 in case of success
 779  * @note It's better to call this function from a dedicated thread
 780  * (see extension_thread.c)
 781  **/
 782 int lua_ExecuteFunctionVa( extensions_manager_t *p_mgr, extension_t *p_ext,
 783                             const char *psz_function, va_list args )
 784 {
 785     int i_ret = VLC_EGENERIC;
 786     int i_args = 0;
 787     assert( p_mgr != NULL );
 788     assert( p_ext != NULL );
 789
 790     lua_State *L = GetLuaState( p_mgr, p_ext );
 791     if( psz_function )
 792         lua_getglobal( L, psz_function );
 793
 794     if( !lua_isfunction( L, -1 ) )
 795     {
 796         msg_Warn( p_mgr, "Error while running script %s, "
 797                   "function %s() not found", p_ext->psz_name, psz_function );
 798         goto exit;
 799     }
 800
 801     lua_datatype_e type = LUA_END;
 802     while( ( type = va_arg( args, int ) ) != LUA_END )
 803     {
 804         if( type == LUA_NUM )
 805         {
 806             lua_pushnumber( L , ( int ) va_arg( args, int ) );
 807         }
 808         else if( type == LUA_TEXT )
 809         {
 810             lua_pushstring( L , ( char * ) va_arg( args, char* ) );
 811         }
 812         else
 813         {
 814             msg_Warn( p_mgr, "Undefined argument type %d to lua function %s"
 815                    "from script %s", type, psz_function, p_ext->psz_name );
 816             goto exit;
 817         }
 818         i_args ++;
 819     }
 820     if( lua_pcall( L, i_args, 1, 0 ) )
 821     {
 822         msg_Warn( p_mgr, "Error while running script %s, "
 823                   "function %s(): %s", p_ext->psz_name, psz_function,
 824                   lua_tostring( L, lua_gettop( L ) ) );
 825         goto exit;
 826     }
 827
 828     i_ret = lua_DialogFlush( L );
 829 exit:
 830     return i_ret;
 831
 832 }
 833
 834 static inline int TriggerMenu( extension_t *p_ext, int i_id )
 835 {
 836     return PushCommand( p_ext, CMD_TRIGGERMENU, i_id );
 837 }
 838
 839 int lua_ExtensionTriggerMenu( extensions_manager_t *p_mgr,
 840                               extension_t *p_ext, int id )
 841 {
 842     int i_ret = VLC_EGENERIC;
 843     lua_State *L = GetLuaState( p_mgr, p_ext );
 844
 845     if( !L )
 846         return VLC_EGENERIC;
 847
 848     luaopen_dialog( L, p_ext );
 849
 850     lua_getglobal( L, "trigger_menu" );
 851     if( !lua_isfunction( L, -1 ) )
 852     {
 853         msg_Warn( p_mgr, "Error while running script %s, "
 854                   "function trigger_menu() not found", p_ext->psz_name );
 855         return VLC_EGENERIC;
 856     }
 857
 858     /* Pass id as unique argument to the function */
 859     lua_pushinteger( L, id );
 860
 861     if( lua_pcall( L, 1, 1, 0 ) != 0 )
 862     {
 863         msg_Warn( p_mgr, "Error while running script %s, "
 864                   "function trigger_menu(): %s", p_ext->psz_name,
 865                   lua_tostring( L, lua_gettop( L ) ) );
 866         return VLC_EGENERIC;
 867     }
 868
 869     i_ret = lua_DialogFlush( L );
 870     if( i_ret < VLC_SUCCESS )
 871     {
 872         msg_Dbg( p_mgr, "Something went wrong in %s (%s:%d)",
 873                  __func__, __FILE__, __LINE__ );
 874     }
 875     return i_ret;
 876 }
 877
 878 /** Directly trigger an extension, without activating it
 879  * This is NOT multithreaded, and this code runs in the UI thread
 880  * @param p_mgr
 881  * @param p_ext Extension to trigger
 882  * @return Value returned by the lua function "trigger"
 883  **/
 884 static int TriggerExtension( extensions_manager_t *p_mgr,
 885                              extension_t *p_ext )
 886 {
 887     int i_ret = lua_ExecuteFunction( p_mgr, p_ext, "trigger", LUA_END );
 888
 889     /* Close lua state for trigger-only extensions */
 890     if( p_ext->p_sys->L )
 891         lua_close( p_ext->p_sys->L );
 892     p_ext->p_sys->L = NULL;
 893
 894     return i_ret;
 895 }
 896
 897 /** Set extension associated to the current script
 898  * @param L current lua_State
 899  * @param p_ext the extension
 900  */
 901 void vlclua_extension_set( lua_State *L, extension_t *p_ext )
 902 {
 903     lua_pushlightuserdata( L, vlclua_extension_set );
 904     lua_pushlightuserdata( L, p_ext );
 905     lua_rawset( L, LUA_REGISTRYINDEX );
 906 }
 907
 908 /** Retrieve extension associated to the current script
 909  * @param L current lua_State
 910  * @return Extension pointer
 911  **/
 912 extension_t *vlclua_extension_get( lua_State *L )
 913 {
 914     lua_pushlightuserdata( L, vlclua_extension_set );
 915     lua_rawget( L, LUA_REGISTRYINDEX );
 916     extension_t *p_ext = (extension_t*) lua_topointer( L, -1 );
 917     lua_pop( L, 1 );
 918     return p_ext;
 919 }
 920
 921 /** Deactivate an extension by order from the extension itself
 922  * @param L lua_State
 923  * @note This is an asynchronous call. A script calling vlc.deactivate() will
 924  * be executed to the end before the last call to deactivate() is done.
 925  **/
 926 int vlclua_extension_deactivate( lua_State *L )
 927 {
 928     extension_t *p_ext = vlclua_extension_get( L );
 929     int i_ret = Deactivate( p_ext->p_sys->p_mgr, p_ext );
 930     return ( i_ret == VLC_SUCCESS ) ? 1 : 0;
 931 }
 932
 933 /** Callback for the variable "dialog-event"
 934  * @param p_this Current object owner of the extension and the dialog
 935  * @param psz_var "dialog-event"
 936  * @param oldval Unused
 937  * @param newval Address of the dialog
 938  * @param p_data Unused
 939  **/
 940 static int vlclua_extension_dialog_callback( vlc_object_t *p_this,
 941                                              char const *psz_var,
 942                                              vlc_value_t oldval,
 943                                              vlc_value_t newval,
 944                                              void *p_data )
 945 {
 946     /* psz_var == "dialog-event" */
 947     ( void ) psz_var;
 948     ( void ) oldval;
 949     ( void ) p_data;
 950
 951     extension_dialog_command_t *command = newval.p_address;
 952     assert( command != NULL );
 953     assert( command->p_dlg != NULL);
 954
 955     extension_t *p_ext = command->p_dlg->p_sys;
 956     assert( p_ext != NULL );
 957
 958     extension_widget_t *p_widget = command->p_data;
 959
 960     switch( command->event )
 961     {
 962         case EXTENSION_EVENT_CLICK:
 963             assert( p_widget != NULL );
 964             PushCommandUnique( p_ext, CMD_CLICK, p_widget );
 965             break;
 966         case EXTENSION_EVENT_CLOSE:
 967             PushCommandUnique( p_ext, CMD_CLOSE );
 968             break;
 969         default:
 970             msg_Dbg( p_this, "Received unknown UI event %d, discarded",
 971                      command->event );
 972             break;
 973     }
 974
 975     return VLC_SUCCESS;
 976 }
 977
 978 /** Callback on vlc_InputItemMetaChanged event
 979  **/
 980 static void inputItemMetaChanged( const vlc_event_t *p_event,
 981                                   void *data )
 982 {
 983     assert( p_event && p_event->type == vlc_InputItemMetaChanged );
 984
 985     extension_t *p_ext = ( extension_t* ) data;
 986     assert( p_ext != NULL );
 987
 988     PushCommandUnique( p_ext, CMD_UPDATE_META );
 989 }
 990
 991 /* Lock this extension. Can fail. */
 992 bool LockExtension( extension_t *p_ext )
 993 {
 994     if( p_ext->p_sys->b_exiting )
 995         return false;
 996
 997     vlc_mutex_lock( &p_ext->p_sys->running_lock );
 998     if( p_ext->p_sys->b_exiting )
 999     {
1000         vlc_mutex_unlock( &p_ext->p_sys->running_lock );
1001         return false;
1002     }
1003
1004     return true;
1005 }
1006
1007 void UnlockExtension( extension_t *p_ext )
1008 {
1009     vlc_mutex_unlock( &p_ext->p_sys->running_lock );
1010 }