videolan
/
vlc
mirror of https://gitea.goldendeliverer.com/videolan/vlc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
104156 Commits
7 Branches
132 Tags
718 MiB
 
 
 
 
 
 
Tree: 586b28f4aa
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '586b28f4aa'
${ noResults }
vlc/modules/lua/extension.c

1126 lines
32 KiB
Raw Blame History

/*****************************************************************************
* extension.c: Lua Extensions (meta data, web information, ...)
*****************************************************************************
* Copyright (C) 2009-2010 VideoLAN and authors
*
* Authors: Jean-Philippe André < jpeg # videolan.org >
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "vlc.h"
#include "libs.h"
#include "extension.h"
#include "assert.h"
#include <vlc_common.h>
#include <vlc_interface.h>
#include <vlc_dialog.h>
#include <vlc_player.h>
/* Functions to register */
static const luaL_Reg p_reg[] =
{
{ NULL, NULL }
};
/*
* Extensions capabilities
* Note: #define and ppsz_capabilities must be in sync
*/
static const char caps[][20] = {
"menu",
"trigger",
"input-listener",
"meta-listener",
"playing-listener",
};
static int ScanExtensions( extensions_manager_t *p_this );
static int ScanLuaCallback( vlc_object_t *p_this, const char *psz_script,
const struct luabatch_context_t * );
static int Control( extensions_manager_t *, int, extension_t *, va_list );
static int GetMenuEntries( extensions_manager_t *p_mgr, extension_t *p_ext,
char ***pppsz_titles, uint16_t **ppi_ids );
static lua_State* GetLuaState( extensions_manager_t *p_mgr,
extension_t *p_ext );
static int TriggerMenu( extension_t *p_ext, int id );
static int TriggerExtension( extensions_manager_t *p_mgr,
extension_t *p_ext );
static void WatchTimerCallback( void* );
static int vlclua_extension_deactivate( lua_State *L );
static int vlclua_extension_keep_alive( lua_State *L );
/* Interactions */
static int vlclua_extension_dialog_callback( vlc_object_t *p_this,
char const *psz_var,
vlc_value_t oldval,
vlc_value_t newval,
void *p_data );
/**
* Module entry-point
**/
int Open_Extension( vlc_object_t *p_this )
{
if( lua_Disabled( p_this ) )
return VLC_EGENERIC;
msg_Dbg( p_this, "Opening Lua Extension module" );
extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
p_mgr->pf_control = Control;
p_mgr->p_sys = NULL;
vlc_mutex_init( &p_mgr->lock );
/* Scan available Lua Extensions */
if( ScanExtensions( p_mgr ) != VLC_SUCCESS )
{
msg_Err( p_mgr, "Can't load extensions modules" );
return VLC_EGENERIC;
}
// Create the dialog-event variable
var_Create( p_this, "dialog-event", VLC_VAR_ADDRESS );
var_AddCallback( p_this, "dialog-event",
vlclua_extension_dialog_callback, NULL );
return VLC_SUCCESS;
}
/**
* Module unload function
**/
void Close_Extension( vlc_object_t *p_this )
{
extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
var_DelCallback( p_this, "dialog-event",
vlclua_extension_dialog_callback, NULL );
var_Destroy( p_mgr, "dialog-event" );
extension_t *p_ext = NULL;
/* Free extensions' memory */
ARRAY_FOREACH( p_ext, p_mgr->extensions )
{
if( !p_ext )
break;
struct lua_extension *sys = p_ext->p_sys;
vlc_mutex_lock(&sys->command_lock);
if (sys->b_activated && sys->p_progress_id == NULL &&
!sys->b_deactivating)
{
// QueueDeactivateCommand will signal the wait condition.
sys->b_exiting = true;
QueueDeactivateCommand( p_ext );
}
else
{
if (sys->L != NULL)
vlclua_fd_interrupt(&sys->dtable);
// however here we need to manually signal the wait cond, since no command is queued.
sys->b_exiting = true;
vlc_cond_signal(&sys->wait);
}
vlc_mutex_unlock(&sys->command_lock);
if (sys->b_thread_running)
vlc_join(sys->thread, NULL);
/* Clear Lua State */
if (sys->L)
{
lua_close(sys->L);
vlclua_fd_cleanup(&sys->dtable);
}
free( p_ext->psz_name );
free( p_ext->psz_title );
free( p_ext->psz_author );
free( p_ext->psz_description );
free( p_ext->psz_shortdescription );
free( p_ext->psz_url );
free( p_ext->psz_version );
free( p_ext->p_icondata );
vlc_timer_destroy(sys->timer);
free( p_ext->p_sys );
free( p_ext );
}
ARRAY_RESET( p_mgr->extensions );
}
/**
* Batch scan all Lua files in folder "extensions"
* @param p_mgr This extensions_manager_t object
**/
static int ScanExtensions( extensions_manager_t *p_mgr )
{
int i_ret =
vlclua_scripts_batch_execute( VLC_OBJECT( p_mgr ),
"extensions",
&ScanLuaCallback,
NULL );
if( !i_ret )
return VLC_EGENERIC;
return VLC_SUCCESS;
}
/**
* Dummy Lua function: does nothing
* @note This function can be used to replace "require" while scanning for
* extensions
* Even the built-in libraries are not loaded when calling descriptor()
**/
static int vlclua_dummy_require( lua_State *L )
{
(void) L;
return 0;
}
/**
* Replacement for "require", adding support for packaged extensions
* @note Loads modules in the modules/ folder of a package
* @note Try first with .luac and then with .lua
**/
static int vlclua_extension_require( lua_State *L )
{
const char *psz_module = luaL_checkstring( L, 1 );
vlc_object_t *p_this = vlclua_get_this( L );
extension_t *p_ext = vlclua_extension_get( L );
msg_Dbg( p_this, "loading module '%s' from extension package",
psz_module );
char *psz_fullpath, *psz_package, *sep;
psz_package = strdup( p_ext->psz_name );
sep = strrchr( psz_package, '/' );
if( !sep )
{
free( psz_package );
return luaL_error( L, "could not find package name" );
}
*sep = '\0';
if( -1 == asprintf( &psz_fullpath,
"%s/modules/%s.luac", psz_package, psz_module ) )
{
free( psz_package );
return 1;
}
int i_ret = vlclua_dofile( p_this, L, psz_fullpath );
if( i_ret != 0 )
{
// Remove trailing 'c' --> try with .lua script
psz_fullpath[ strlen( psz_fullpath ) - 1 ] = '\0';
i_ret = vlclua_dofile( p_this, L, psz_fullpath );
}
free( psz_fullpath );
free( psz_package );
if( i_ret != 0 )
{
return luaL_error( L, "unable to load module '%s' from package",
psz_module );
}
return 0;
}
static char *
GetStringFieldOrNull(lua_State *L, const char *name)
{
lua_getfield(L, -1, name);
char *value = luaL_strdupornull(L, -1);
lua_pop(L, 1);
return value;
}
/**
* Batch scan all Lua files in folder "extensions": callback
* @param p_this This extensions_manager_t object
* @param psz_filename Name of the script to run
* @param L Lua State, common to all scripts here
* @param dummy: unused
**/
int ScanLuaCallback( vlc_object_t *p_this, const char *psz_filename,
const struct luabatch_context_t *dummy )
{
VLC_UNUSED(dummy);
extensions_manager_t *p_mgr = ( extensions_manager_t* ) p_this;
msg_Dbg( p_mgr, "Scanning Lua script %s", psz_filename );
/* Experimental: read .vle packages (Zip archives) */
char *psz_script = NULL;
char *extension = strrchr(psz_filename, '.');
if (extension != NULL && strcmp(extension, ".vle") == 0)
{
msg_Dbg( p_this, "reading Lua script in a zip archive" );
if (asprintf(&psz_script, "zip://%s!/script.lua", psz_filename) == -1)
return VLC_ENOMEM;
}
else
{
psz_script = strdup( psz_filename );
if( !psz_script )
return 0;
}
/* Create new script descriptor */
extension_t *p_ext = calloc( 1, sizeof( extension_t ) );
if( !p_ext )
{
free( psz_script );
return 0;
}
p_ext->logger = vlc_object_logger(p_mgr);
p_ext->psz_name = psz_script;
struct lua_extension *sys
= p_ext->p_sys
= calloc(1, sizeof(*sys));
if (sys == NULL || !p_ext->psz_name)
{
free( p_ext->psz_name );
free(sys);
free( p_ext );
return 0;
}
sys->p_mgr = p_mgr;
/* Watch timer */
if( vlc_timer_create( &sys->timer, WatchTimerCallback, p_ext ) )
{
free( p_ext->psz_name );
free(sys);
free( p_ext );
return 0;
}
/* Mutexes and conditions */
vlc_mutex_init(&sys->command_lock);
vlc_mutex_init(&sys->running_lock);
vlc_cond_init(&sys->wait);
/* Prepare Lua state */
lua_State *L = luaL_newstate();
lua_register( L, "require", &vlclua_dummy_require );
/* Let's run it */
if( vlclua_dofile( p_this, L, psz_script ) ) // luaL_dofile
{
msg_Warn( p_mgr, "Error loading script %s: %s", psz_script,
lua_tostring( L, lua_gettop( L ) ) );
lua_pop( L, 1 );
goto discard;
}
/* Scan script for capabilities */
lua_getglobal( L, "descriptor" );
if( !lua_isfunction( L, -1 ) )
{
msg_Warn( p_mgr, "Error while running script %s, "
"function descriptor() not found", psz_script );
goto discard;
}
if( lua_pcall( L, 0, 1, 0 ) )
{
msg_Warn( p_mgr, "Error while running script %s, "
"function descriptor(): %s", psz_script,
lua_tostring( L, lua_gettop( L ) ) );
goto discard;
}
if (lua_gettop(L) == 0)
{
msg_Err(p_mgr, "Script %s went completely foobar", psz_script);
goto discard;
}
if (!lua_istable(L, -1))
{
msg_Warn(p_mgr, "In script %s, function descriptor() "
"did not return a table!", psz_script);
goto discard;
}
/* Get caps */
lua_getfield(L, -1, "capabilities");
if (lua_istable(L, -1))
{
lua_pushnil(L);
while (lua_next(L, -2) != 0)
{
/* Key is at index -2 and value at index -1. Discard key */
const char *psz_cap = luaL_checkstring(L, -1);
bool found = false;
/* Find this capability's flag */
for (size_t i = 0; i < ARRAY_SIZE(caps); i++)
{
if (!strcmp(caps[i], psz_cap))
{
/* Flag it! */
sys->i_capabilities |= 1 << i;
found = true;
break;
}
}
if (!found)
{
msg_Warn(p_mgr, "Extension capability '%s' unknown in"
" script %s", psz_cap, psz_script);
}
/* Removes 'value'; keeps 'key' for next iteration */
lua_pop(L, 1);
}
}
else
{
msg_Warn(p_mgr, "In script %s, function descriptor() "
"did not return a table of capabilities.",
psz_script);
}
lua_pop(L, 1);
/* Get title */
lua_getfield(L, -1, "title");
if (lua_isstring(L, -1))
{
p_ext->psz_title = strdup(luaL_checkstring(L, -1));
}
else
{
msg_Dbg(p_mgr,"In script %s, function descriptor() "
"did not return a string as title.",
psz_script);
p_ext->psz_title = strdup(psz_script);
}
lua_pop(L, 1);
/* Get the fields from the extension manifest. */
p_ext->psz_author = GetStringFieldOrNull(L, "author");
p_ext->psz_description = GetStringFieldOrNull(L, "description");
p_ext->psz_shortdescription = GetStringFieldOrNull(L, "shortdesc");
p_ext->psz_url = GetStringFieldOrNull(L, "url");
p_ext->psz_version = GetStringFieldOrNull(L, "version");
/* Get icon data */
lua_getfield(L, -1, "icon");
if (!lua_isnil(L, -1) && lua_isstring(L, -1))
{
int len = lua_strlen(L, -1);
p_ext->p_icondata = malloc(len);
if (p_ext->p_icondata)
{
p_ext->i_icondata_size = len;
memcpy(p_ext->p_icondata, lua_tostring(L, -1), len);
}
}
lua_pop(L, 1);
msg_Dbg(p_mgr, "Script %s has the following capability flags: 0x%x",
psz_script, sys->i_capabilities);
lua_close( L );
/* Add the extension to the list of known extensions */
ARRAY_APPEND(p_mgr->extensions, p_ext);
/* Continue batch execution */
return VLC_EGENERIC;
discard:
lua_close(L);
free(p_ext->psz_name);
free(p_ext->psz_title);
free(p_ext->psz_url);
free(p_ext->psz_author);
free(p_ext->psz_description);
free(p_ext->psz_shortdescription);
free(p_ext->psz_version);
free(p_ext);
free(sys);
return VLC_EGENERIC;
}
static int Control(extensions_manager_t *p_mgr, int i_control,
extension_t *ext, va_list args)
{
struct lua_extension *sys = ext->p_sys;
bool *pb = NULL;
uint16_t **ppus = NULL;
char ***pppsz = NULL;
int i = 0;
switch( i_control )
{
case EXTENSION_ACTIVATE:
return Activate(ext);
case EXTENSION_DEACTIVATE:
return Deactivate(p_mgr, ext);
case EXTENSION_IS_ACTIVATED:
pb = va_arg( args, bool* );
vlc_mutex_lock(&sys->command_lock);
*pb = sys->b_activated;
vlc_mutex_unlock(&sys->command_lock);
break;
case EXTENSION_HAS_MENU:
pb = va_arg( args, bool* );
*pb = (sys->i_capabilities & EXT_HAS_MENU) ? 1 : 0;
break;
case EXTENSION_GET_MENU:
pppsz = va_arg( args, char*** );
ppus = va_arg( args, uint16_t** );
return GetMenuEntries(p_mgr, ext, pppsz, ppus);
case EXTENSION_TRIGGER_ONLY:
pb = va_arg( args, bool* );
*pb = (sys->i_capabilities & EXT_TRIGGER_ONLY) ? 1 : 0;
break;
case EXTENSION_TRIGGER:
return TriggerExtension(p_mgr, ext);
case EXTENSION_TRIGGER_MENU:
i = va_arg( args, int );
return TriggerMenu(ext, i);
case EXTENSION_SET_INPUT:
{
input_item_t *p_item = va_arg( args, struct input_item_t * );
vlc_mutex_lock(&sys->command_lock);
if (sys->b_exiting)
{
vlc_mutex_unlock(&sys->command_lock);
return VLC_EGENERIC;
}
vlc_mutex_unlock(&sys->command_lock);
vlc_mutex_lock(&sys->running_lock);
// Change input
input_item_t *old = sys->p_item;
if( old )
input_item_Release( old );
sys->p_item = p_item ? input_item_Hold(p_item) : NULL;
// Tell the script the input changed
if (sys->i_capabilities & EXT_INPUT_LISTENER)
{
PushCommandUnique(ext, CMD_SET_INPUT);
}
vlc_mutex_unlock(&sys->running_lock);
break;
}
case EXTENSION_PLAYING_CHANGED:
{
assert(ext->psz_name != NULL);
i = va_arg( args, int );
if (sys->i_capabilities & EXT_PLAYING_LISTENER)
{
PushCommand(ext, CMD_PLAYING_CHANGED, i);
}
break;
}
case EXTENSION_META_CHANGED:
{
PushCommand(ext, CMD_UPDATE_META);
break;
}
default:
msg_Warn( p_mgr, "Control '%d' not yet implemented in Extension",
i_control );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
int lua_ExtensionActivate( extensions_manager_t *p_mgr, extension_t *p_ext )
{
assert( p_mgr != NULL && p_ext != NULL );
return lua_ExecuteFunction( p_mgr, p_ext, "activate", LUA_END );
}
int lua_ExtensionDeactivate( extensions_manager_t *p_mgr, extension_t *p_ext )
{
assert( p_mgr != NULL && p_ext != NULL );
struct lua_extension *sys = p_ext->p_sys;
vlclua_fd_interrupt(&sys->dtable);
// Unset and release input objects
if (sys->p_item)
{
input_item_Release(sys->p_item);
sys->p_item = NULL;
}
return lua_ExecuteFunction( p_mgr, p_ext, "deactivate", LUA_END );
}
int lua_ExtensionWidgetClick( extensions_manager_t *p_mgr,
extension_t *p_ext,
extension_widget_t *p_widget )
{
struct lua_extension *sys = p_ext->p_sys;
if (sys->L == NULL)
return VLC_SUCCESS;
lua_State *L = GetLuaState( p_mgr, p_ext );
lua_pushlightuserdata( L, p_widget );
lua_gettable( L, LUA_REGISTRYINDEX );
return lua_ExecuteFunction( p_mgr, p_ext, NULL, LUA_END );
}
/**
* Get the list of menu entries from an extension script
* @param p_mgr
* @param p_ext
* @param pppsz_titles Pointer to NULL. All strings must be freed by the caller
* @param ppi_ids Pointer to NULL. Must be freed by the caller.
* @note This function is allowed to run in the UI thread. This means
* that it MUST respond very fast.
* @todo Remove the menu() hook and provide a new function vlc.set_menu()
**/
static int GetMenuEntries( extensions_manager_t *p_mgr, extension_t *p_ext,
char ***pppsz_titles, uint16_t **ppi_ids )
{
assert( *pppsz_titles == NULL );
assert( *ppi_ids == NULL );
struct lua_extension *sys = p_ext->p_sys;
vlc_mutex_lock(&sys->command_lock);
if (!sys->b_activated || sys->b_exiting)
{
vlc_mutex_unlock(&sys->command_lock);
msg_Dbg( p_mgr, "Can't get menu of an unactivated/dying extension!" );
return VLC_EGENERIC;
}
vlc_mutex_unlock(&sys->command_lock);
vlc_mutex_lock(&sys->running_lock);
int i_ret = VLC_EGENERIC;
lua_State *L = GetLuaState( p_mgr, p_ext );
if ((sys->i_capabilities & EXT_HAS_MENU) == 0)
{
msg_Dbg( p_mgr, "can't get a menu from an extension without menu!" );
goto exit;
}
lua_getglobal( L, "menu" );
if( !lua_isfunction( L, -1 ) )
{
msg_Warn( p_mgr, "Error while running script %s, "
"function menu() not found", p_ext->psz_name );
goto exit;
}
if( lua_pcall( L, 0, 1, 0 ) )
{
msg_Warn( p_mgr, "Error while running script %s, "
"function menu(): %s", p_ext->psz_name,
lua_tostring( L, lua_gettop( L ) ) );
goto exit;
}
if (lua_gettop(L) == 0)
{
msg_Warn(p_mgr, "Script %s went completely foobar", p_ext->psz_name);
goto exit;
}
if (!lua_istable(L, -1))
{
msg_Warn(p_mgr, "Function menu() in script %s "
"did not return a table", p_ext->psz_name);
goto exit;
}
/* Get table size */
size_t i_size = lua_objlen( L, -1 );
*pppsz_titles = calloc(i_size+1, sizeof(**pppsz_titles));
*ppi_ids = calloc(i_size+1, sizeof(**ppi_ids));
/* Walk table */
size_t i_idx = 0;
lua_pushnil(L);
while (lua_next(L, -2) != 0)
{
assert(i_idx < i_size);
if(!lua_isstring(L, -1) || !lua_isnumber(L, -2))
{
msg_Warn(p_mgr, "In script %s, an entry in "
"the menu table is invalid!", p_ext->psz_name);
goto exit;
}
(*pppsz_titles)[i_idx] = strdup(luaL_checkstring(L, -1));
(*ppi_ids)[i_idx] = luaL_checkinteger(L, -2) & 0xFFFF;
i_idx++;
lua_pop(L, 1);
}
i_ret = VLC_SUCCESS;
exit:
vlc_mutex_unlock(&sys->running_lock);
if( i_ret != VLC_SUCCESS )
{
msg_Dbg( p_mgr, "Something went wrong in %s (%s:%d)",
__func__, __FILE__, __LINE__ );
}
return i_ret;
}
/* Must be entered with the Lock on Extension */
static lua_State* GetLuaState( extensions_manager_t *p_mgr,
extension_t *p_ext )
{
assert( p_ext != NULL );
struct lua_extension *sys = p_ext->p_sys;
if (sys->L != NULL)
return sys->L;
lua_State *L = luaL_newstate();
if (L == NULL)
{
msg_Err(p_mgr, "Could not create new Lua State");
return NULL;
}
vlclua_set_this(L, p_mgr);
intf_thread_t *intf = (intf_thread_t *)vlc_object_parent(p_mgr);
vlc_playlist_t *playlist = vlc_intf_GetMainPlaylist(intf);
vlclua_set_playlist_internal(L, playlist);
vlclua_extension_set(L, p_ext);
luaL_openlibs(L);
luaL_register_namespace(L, "vlc", p_reg);
luaopen_msg(L);
/* Load more libraries */
luaopen_config(L);
luaopen_dialog(L, p_ext);
luaopen_input(L);
luaopen_msg(L);
if (vlclua_fd_init(L, &sys->dtable))
{
lua_close(L);
return NULL;
}
luaopen_object(L);
luaopen_osd(L);
luaopen_playlist(L);
luaopen_stream(L);
luaopen_strings(L);
luaopen_variables(L);
luaopen_video(L);
luaopen_vlm(L);
luaopen_volume(L);
luaopen_xml(L);
luaopen_vlcio(L);
luaopen_errno(L);
luaopen_rand(L);
luaopen_rd(L);
luaopen_ml(L);
#if defined(_WIN32)
# if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
luaopen_win(L);
# endif
#endif
/* Register extension specific functions */
lua_getglobal(L, "vlc");
lua_pushcfunction(L, vlclua_extension_deactivate);
lua_setfield(L, -2, "deactivate");
lua_pushcfunction(L, vlclua_extension_keep_alive);
lua_setfield(L, -2, "keep_alive");
/* Setup the module search path */
if (!strncmp(p_ext->psz_name, "zip://", 6))
{
/* Load all required modules manually */
lua_register(L, "require", &vlclua_extension_require);
}
else if (vlclua_add_modules_path(L, p_ext->psz_name))
{
msg_Warn(p_mgr, "Error while setting the module "
"search path for %s", p_ext->psz_name);
vlclua_fd_cleanup(&sys->dtable);
lua_close(L);
return NULL;
}
/* Load and run the script(s) */
if (vlclua_dofile(VLC_OBJECT(p_mgr), L, p_ext->psz_name))
{
msg_Warn(p_mgr, "Error loading script %s: %s", p_ext->psz_name,
lua_tostring(L, lua_gettop(L)));
vlclua_fd_cleanup(&sys->dtable);
lua_close(L);
return NULL;
}
sys->L = L;
return L;
}
int lua_ExecuteFunction( extensions_manager_t *p_mgr, extension_t *p_ext,
const char *psz_function, ... )
{
va_list args;
va_start( args, psz_function );
int i_ret = lua_ExecuteFunctionVa( p_mgr, p_ext, psz_function, args );
va_end( args );
return i_ret;
}
/**
* Execute a function in a Lua script
* @param psz_function Name of global function to execute. If NULL, assume
* that the function object is already on top of the
* stack.
* @return < 0 in case of failure, >= 0 in case of success
* @note It's better to call this function from a dedicated thread
* (see extension_thread.c)
**/
int lua_ExecuteFunctionVa( extensions_manager_t *p_mgr, extension_t *p_ext,
const char *psz_function, va_list args )
{
int i_ret = VLC_SUCCESS;
int i_args = 0;
assert( p_mgr != NULL );
assert( p_ext != NULL );
lua_State *L = GetLuaState( p_mgr, p_ext );
if( !L )
return -1;
if( psz_function )
lua_getglobal( L, psz_function );
if( !lua_isfunction( L, -1 ) )
{
msg_Warn( p_mgr, "Error while running script %s, "
"function %s() not found", p_ext->psz_name, psz_function );
lua_pop( L, 1 );
goto exit;
}
lua_datatype_e type = LUA_END;
while( ( type = va_arg( args, int ) ) != LUA_END )
{
if( type == LUA_NUM )
{
lua_pushnumber( L , va_arg( args, int ) );
}
else if( type == LUA_TEXT )
{
lua_pushstring( L , va_arg( args, char* ) );
}
else
{
msg_Warn( p_mgr, "Undefined argument type %d to lua function %s"
"from script %s", type, psz_function, p_ext->psz_name );
if( i_args > 0 )
lua_pop( L, i_args );
goto exit;
}
i_args ++;
}
// Start actual call to Lua
if( lua_pcall( L, i_args, 1, 0 ) )
{
msg_Warn( p_mgr, "Error while running script %s, "
"function %s(): %s", p_ext->psz_name, psz_function,
lua_tostring( L, lua_gettop( L ) ) );
i_ret = VLC_EGENERIC;
}
if (i_ret != VLC_SUCCESS)
lua_DialogFlush( L );
else
i_ret = lua_DialogFlush( L );
exit:
return i_ret;
}
static inline int TriggerMenu( extension_t *p_ext, int i_id )
{
return PushCommand( p_ext, CMD_TRIGGERMENU, i_id );
}
int lua_ExtensionTriggerMenu( extensions_manager_t *p_mgr,
extension_t *p_ext, int id )
{
int i_ret = VLC_SUCCESS;
lua_State *L = GetLuaState( p_mgr, p_ext );
if( !L )
return VLC_EGENERIC;
luaopen_dialog( L, p_ext );
lua_getglobal( L, "trigger_menu" );
if( !lua_isfunction( L, -1 ) )
{
msg_Warn( p_mgr, "Error while running script %s, "
"function trigger_menu() not found", p_ext->psz_name );
return VLC_EGENERIC;
}
/* Pass id as unique argument to the function */
lua_pushinteger( L, id );
if( lua_pcall( L, 1, 1, 0 ) != 0 )
{
msg_Warn( p_mgr, "Error while running script %s, "
"function trigger_menu(): %s", p_ext->psz_name,
lua_tostring( L, lua_gettop( L ) ) );
i_ret = VLC_EGENERIC;
}
if (i_ret != VLC_SUCCESS)
lua_DialogFlush( L );
else
i_ret = lua_DialogFlush( L );
if( i_ret < VLC_SUCCESS )
{
msg_Dbg( p_mgr, "Something went wrong in %s (%s:%d)",
__func__, __FILE__, __LINE__ );
}
return i_ret;
}
/** Directly trigger an extension, without activating it
* This is NOT multithreaded, and this code runs in the UI thread
* @param p_mgr
* @param p_ext Extension to trigger
* @return Value returned by the lua function "trigger"
**/
static int TriggerExtension( extensions_manager_t *p_mgr,
extension_t *p_ext )
{
struct lua_extension *sys = p_ext->p_sys;
int i_ret = lua_ExecuteFunction( p_mgr, p_ext, "trigger", LUA_END );
/* Close lua state for trigger-only extensions */
if (sys->L)
{
vlclua_fd_cleanup(&sys->dtable);
lua_close(sys->L);
}
sys->L = NULL;
return i_ret;
}
/** Set extension associated to the current script
* @param L current lua_State
* @param p_ext the extension
*/
void vlclua_extension_set( lua_State *L, extension_t *p_ext )
{
lua_pushlightuserdata( L, vlclua_extension_set );
lua_pushlightuserdata( L, p_ext );
lua_rawset( L, LUA_REGISTRYINDEX );
}
/** Retrieve extension associated to the current script
* @param L current lua_State
* @return Extension pointer
**/
extension_t *vlclua_extension_get( lua_State *L )
{
lua_pushlightuserdata( L, vlclua_extension_set );
lua_rawget( L, LUA_REGISTRYINDEX );
extension_t *p_ext = (extension_t*) lua_topointer( L, -1 );
lua_pop( L, 1 );
return p_ext;
}
/** Deactivate an extension by order from the extension itself
* @param L lua_State
* @note This is an asynchronous call. A script calling vlc.deactivate() will
* be executed to the end before the last call to deactivate() is done.
**/
int vlclua_extension_deactivate( lua_State *L )
{
extension_t *p_ext = vlclua_extension_get( L );
struct lua_extension *sys = p_ext->p_sys;
vlc_mutex_lock(&sys->command_lock);
bool b_ret = QueueDeactivateCommand( p_ext );
vlc_mutex_unlock(&sys->command_lock);
return ( b_ret == true ) ? 1 : 0;
}
/** Keep an extension alive. This resets the watch timer to 0
* @param L lua_State
* @note This is the "vlc.keep_alive()" function
**/
int vlclua_extension_keep_alive( lua_State *L )
{
extension_t *p_ext = vlclua_extension_get( L );
struct lua_extension *sys = p_ext->p_sys;
vlc_mutex_lock(&sys->command_lock);
if (sys->p_progress_id != NULL)
{
vlc_dialog_release(sys->p_mgr, sys->p_progress_id);
sys->p_progress_id = NULL;
}
vlc_timer_schedule(sys->timer, false, WATCH_TIMER_PERIOD,
VLC_TIMER_FIRE_ONCE);
vlc_mutex_unlock(&sys->command_lock);
return 1;
}
/** Callback for the variable "dialog-event"
* @param p_this Current object owner of the extension and the dialog
* @param psz_var "dialog-event"
* @param oldval Unused
* @param newval Address of the dialog
* @param p_data Unused
**/
static int vlclua_extension_dialog_callback( vlc_object_t *p_this,
char const *psz_var,
vlc_value_t oldval,
vlc_value_t newval,
void *p_data )
{
/* psz_var == "dialog-event" */
( void ) psz_var;
( void ) oldval;
( void ) p_data;
extension_dialog_command_t *command = newval.p_address;
assert( command != NULL );
assert( command->p_dlg != NULL);
extension_t *p_ext = command->p_dlg->p_sys;
assert( p_ext != NULL );
extension_widget_t *p_widget = command->p_data;
switch( command->event )
{
case EXTENSION_EVENT_CLICK:
assert( p_widget != NULL );
PushCommandUnique( p_ext, CMD_CLICK, p_widget );
break;
case EXTENSION_EVENT_CLOSE:
PushCommandUnique( p_ext, CMD_CLOSE );
break;
default:
msg_Dbg( p_this, "Received unknown UI event %d, discarded",
command->event );
break;
}
return VLC_SUCCESS;
}
/** Watch timer callback
* The timer expired, Lua may be stuck, ask the user what to do now
**/
static void WatchTimerCallback( void *data )
{
extension_t *p_ext = data;
struct lua_extension *sys = p_ext->p_sys;
extensions_manager_t *p_mgr = sys->p_mgr;
vlc_mutex_lock(&sys->command_lock);
for( struct command_t *cmd = sys->command;
cmd != NULL;
cmd = cmd->next )
if( cmd->i_command == CMD_DEACTIVATE )
{ /* We have a pending Deactivate command... */
if (sys->p_progress_id != NULL)
{
vlc_dialog_release(p_mgr, sys->p_progress_id);
sys->p_progress_id = NULL;
}
KillExtension(p_ext);
vlc_mutex_unlock(&sys->command_lock);
return;
}
if (sys->p_progress_id == NULL)
{
sys->p_progress_id =
vlc_dialog_display_progress( p_mgr, true, 0.0,
_( "Yes" ),
_( "Extension not responding!" ),
_( "Extension '%s' does not respond.\n"
"Do you want to kill it now? " ),
p_ext->psz_title );
if (sys->p_progress_id == NULL)
{
KillExtension(p_ext);
vlc_mutex_unlock(&sys->command_lock);
return;
}
vlc_timer_schedule(sys->timer, false, VLC_TICK_FROM_MS(100),
VLC_TIMER_FIRE_ONCE);
}
else
{
if (vlc_dialog_is_cancelled(p_mgr, sys->p_progress_id))
{
vlc_dialog_release(p_mgr, sys->p_progress_id);
sys->p_progress_id = NULL;
KillExtension(p_ext);
vlc_mutex_unlock(&sys->command_lock);
return;
}
vlc_timer_schedule(sys->timer, false, VLC_TICK_FROM_MS(100),
VLC_TIMER_FIRE_ONCE);
}
vlc_mutex_unlock(&sys->command_lock);
}