blob: 6b24984130f4c1514fb38c75db7be1e3a3c652ce [file] [log] [blame]
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2008 Dan Everton (safetydan)
* Copyright (C) 2009 Maurus Cuelenaere
* Copyright (C) 2018 William Wilgus
*
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#define lrocklib_c
#define LUA_LIB
#include "lua.h"
#include "lstring.h"
#include "lauxlib.h"
#include "rocklib.h"
#include "lib/helper.h"
/*
* http://www.lua.org/manual/5.1/manual.html#lua_CFunction
*
* In order to communicate properly with Lua, a C function must use the following protocol,
* which defines the way parameters and results are passed: a C function receives its arguments
* from Lua in its stack in direct order (the first argument is pushed first). To return values to Lua,
* a C function just pushes them onto the stack, in direct order (the first result is pushed first),
* and returns the number of results. Any other value in the stack below the results will be properly
* discarded by Lua. Like a Lua function, a C function called by Lua can also return many results.
*
* When porting new functions, don't forget to check rocklib_aux.pl whether it automatically creates
* wrappers for the function and if so, add the function names to @forbidden_functions. This is to
* prevent namespace collisions and adding duplicate wrappers.
*/
/*
* -----------------------------
*
* Rockbox wrappers start here!
*
* -----------------------------
*/
#define RB_WRAP(func) static int rock_##func(lua_State UNUSED_ATTR *L)
#define SIMPLE_VOID_WRAPPER(func) RB_WRAP(func) { (void)L; func(); return 0; }
/* KERNEL */
RB_WRAP(current_tick)
{
lua_pushinteger(L, *rb->current_tick);
return 1;
}
#ifdef HAVE_SCHEDULER_BOOSTCTRL
RB_WRAP(schedule_cpu_boost)
{
bool boost = luaL_checkboolean(L, 1);
if(boost)
rb->trigger_cpu_boost();
else
rb->cancel_cpu_boost();
return 0;
}
#endif
RB_WRAP(sleep)
{
unsigned ticks = (unsigned) lua_tonumber(L, 1);
rb->sleep(ticks);
return 0;
}
#ifdef HAVE_PRIORITY_SCHEDULING
RB_WRAP(thread_set_priority)
{
unsigned int thread_id = rb->thread_self();
int priority = (int) luaL_checkint(L, 1);
int result = rb->thread_set_priority(thread_id, priority);
lua_pushinteger(L, result);
return 1;
}
#endif
RB_WRAP(current_path)
{
return get_current_path(L, 1);
}
/* DEVICE INPUT CONTROL */
RB_WRAP(get_plugin_action)
{
int timeout = luaL_checkint(L, 1);
bool with_remote = luaL_optint(L, 2, 0);
int btn = get_plugin_action(timeout, with_remote);
lua_pushinteger(L, btn);
return 1;
}
#ifdef HAVE_TOUCHSCREEN
RB_WRAP(action_get_touchscreen_press)
{
short x, y;
int result = rb->action_get_touchscreen_press(&x, &y);
lua_pushinteger(L, result);
lua_pushinteger(L, x);
lua_pushinteger(L, y);
return 3;
}
RB_WRAP(touchscreen_mode)
{
int origmode = rb->touchscreen_get_mode();
if(!lua_isnoneornil(L, 1))
{
enum touchscreen_mode mode = luaL_checkint(L, 1);
rb->touchscreen_set_mode(mode);
}
lua_pushinteger(L, origmode);
return 1;
}
#endif
RB_WRAP(kbd_input)
{
luaL_Buffer b;
luaL_buffinit(L, &b);
const char *input = lua_tostring(L, 1);
char *buffer = luaL_prepbuffer(&b);
if(input != NULL)
rb->strlcpy(buffer, input, LUAL_BUFFERSIZE);
else
buffer[0] = '\0';
if(!rb->kbd_input(buffer, LUAL_BUFFERSIZE))
{
luaL_addstring(&b, buffer);
luaL_pushresult(&b);
}
else
return 0;
return 1;
}
static const char ** get_table_items(lua_State *L, int pos, int *count)
{
int i;
luaL_checktype(L, pos, LUA_TTABLE);
*count = lua_objlen(L, pos);
int n = *count;
/* newuserdata will be pushed onto stack after args*/
const char **items = (const char**) lua_newuserdata(L, n * sizeof(const char*));
for(i=1; i<= n; i++)
{
lua_rawgeti(L, pos, i); /* Push item on the stack */
items[i-1] = lua_tostring(L, -1);
lua_pop(L, 1); /* Pop it */
}
return items;
}
static inline void fill_text_message(lua_State *L, struct text_message * message,
int pos)
{
int n;
/* newuserdata will be pushed onto stack after args*/
message->message_lines = get_table_items(L, pos, &n);
message->nb_lines = n;
}
RB_WRAP(gui_syncyesno_run)
{
struct text_message main_message, yes_message, no_message;
struct text_message *yes = NULL, *no = NULL;
lua_settop(L, 3); /* newuserdata will be pushed onto stack after args*/
fill_text_message(L, &main_message, 1);
if(!lua_isnoneornil(L, 2))
fill_text_message(L, (yes = &yes_message), 2);
if(!lua_isnoneornil(L, 3))
fill_text_message(L, (no = &no_message), 3);
enum yesno_res result = rb->gui_syncyesno_run(&main_message, yes, no);
lua_pushinteger(L, result);
return 1;
}
static lua_State* store_luastate(lua_State *L, bool bStore)
{
/* it is dangerous to store the lua state byond its guaranteed lifetime
be sure to clear state asap (as in before you exit the calling function) */
static lua_State *LStored = NULL;
if(bStore)
LStored = L;
return LStored;
}
static int menu_callback(int action, const struct menu_item_ex *this_item)
{
(void) this_item;
static int lua_ref = LUA_NOREF;
lua_State *L = store_luastate(NULL, false);
if(!L)
{
lua_ref = action;
action = ACTION_STD_CANCEL;
}
else if (lua_ref != LUA_NOREF)
{
lua_rawgeti(L, LUA_REGISTRYINDEX, lua_ref);
lua_pushnumber(L, action);
lua_pcall (L, 1, 1, 0);
action = luaL_optnumber (L, -1, ACTION_STD_CANCEL);
lua_pop(L, 1);
}
return action;
}
RB_WRAP(do_menu)
{
struct menu_callback_with_desc menu_desc = {NULL, NULL, Icon_NOICON};
struct menu_item_ex menu = {MT_RETURN_ID | MENU_HAS_DESC, {.strings = NULL},
{.callback_and_desc = &menu_desc}};
int n, start_selected;
int ref_lua = LUA_NOREF;
const char **items, *title;
title = luaL_checkstring(L, 1);
start_selected = lua_tointeger(L, 3);
if (lua_isfunction (L, -1))
{
/*lua callback function cb(action) return action end */
ref_lua = luaL_ref(L, LUA_REGISTRYINDEX);
menu_callback(ref_lua, NULL);
store_luastate(L, true);
menu_desc.menu_callback = &menu_callback;
}
/* newuserdata will be pushed onto stack after args*/
items = get_table_items(L, 2, &n);
menu.strings = items;
menu.flags |= MENU_ITEM_COUNT(n);
menu_desc.desc = (unsigned char*) title;
int result = rb->do_menu(&menu, &start_selected, NULL, false);
if (ref_lua != LUA_NOREF)
{
store_luastate(NULL, true);
luaL_unref (L, LUA_REGISTRYINDEX, ref_lua);
menu_callback(LUA_NOREF, NULL);
}
lua_pushinteger(L, result);
return 1;
}
/* DEVICE AUDIO / PLAYLIST CONTROL */
RB_WRAP(playlist)
{
/* just passes NULL to work with the current playlist */
enum e_playlist {PLAYL_AMOUNT = 0, PLAYL_ADD, PLAYL_CREATE,
PLAYL_START, PLAYL_RESUMETRACK, PLAYL_RESUME,
PLAYL_SHUFFLE, PLAYL_SYNC, PLAYL_REMOVEALLTRACKS,
PLAYL_INSERTTRACK, PLAYL_INSERTDIRECTORY, PLAYL_ECOUNT};
const char *playlist_option[] = {"amount", "add", "create", "start", "resume_track",
"resume", "shuffle", "sync", "remove_all_tracks",
"insert_track", "insert_directory", NULL};
const char *filename, *dir;
int result = 0;
bool queue, recurse, sync;
int pos, crc, index, random_seed;
unsigned long elapsed, offset;
int option = luaL_checkoption (L, 1, NULL, playlist_option);
switch(option)
{
case PLAYL_AMOUNT:
result = rb->playlist_amount();
break;
case PLAYL_ADD:
filename = luaL_checkstring(L, 2);
result = rb->playlist_add(filename);
break;
case PLAYL_CREATE:
dir = luaL_checkstring(L, 2);
filename = luaL_checkstring(L, 3);
result = rb->playlist_create(dir, filename);
break;
case PLAYL_START:
index = luaL_checkint(L, 2);
elapsed = luaL_checkint(L, 3);
offset = luaL_checkint(L, 4);
rb->playlist_start(index, elapsed, offset);
break;
case PLAYL_RESUMETRACK:
index = luaL_checkint(L, 2);
crc = luaL_checkint(L, 3);
elapsed = luaL_checkint(L, 4);
offset = luaL_checkint(L, 5);
rb->playlist_resume_track(index, (unsigned) crc, elapsed, offset);
break;
case PLAYL_RESUME:
result = rb->playlist_resume();
break;
case PLAYL_SHUFFLE:
random_seed = luaL_checkint(L, 2);
index = luaL_checkint(L, 3);
result = rb->playlist_shuffle(random_seed, index);
break;
case PLAYL_SYNC:
rb->playlist_sync(NULL);
break;
case PLAYL_REMOVEALLTRACKS:
result = rb->playlist_remove_all_tracks(NULL);
break;
case PLAYL_INSERTTRACK:
filename = luaL_checkstring(L, 2); /* only required parameter */
pos = luaL_optint(L, 3, PLAYLIST_INSERT);
queue = lua_toboolean(L, 4); /* default to false */
sync = lua_toboolean(L, 5); /* default to false */
result = rb->playlist_insert_track(NULL, filename, pos, queue, sync);
break;
case PLAYL_INSERTDIRECTORY:
dir = luaL_checkstring(L, 2); /* only required parameter */
pos = luaL_optint(L, 3, PLAYLIST_INSERT);
queue = lua_toboolean(L, 4); /* default to false */
recurse = lua_toboolean(L, 5); /* default to false */
result = rb->playlist_insert_directory(NULL, dir, pos, queue, recurse);
break;
}
yield();
lua_pushinteger(L, result);
return 1;
}
RB_WRAP(audio)
{
enum e_audio {AUDIO_STATUS = 0, AUDIO_PLAY, AUDIO_STOP, AUDIO_PAUSE,
AUDIO_RESUME, AUDIO_NEXT, AUDIO_PREV, AUDIO_FFREWIND,
AUDIO_FLUSHANDRELOADTRACKS, AUDIO_GETPOS, AUDIO_LENGTH,
AUDIO_ELAPSED, AUDIO_ECOUNT};
const char *audio_option[] = {"status", "play", "stop",
"pause", "resume", "next",
"prev", "ff_rewind",
"flush_and_reload_tracks",
"get_file_pos", "length",
"elapsed", NULL};
long elapsed, offset, newtime;
int status = rb->audio_status();
int option = luaL_checkoption (L, 1, NULL, audio_option);
switch(option)
{
case AUDIO_STATUS:
break;
case AUDIO_PLAY:
elapsed = luaL_checkint(L, 2);
offset = luaL_checkint(L, 3);
if (status == (AUDIO_STATUS_PLAY | AUDIO_STATUS_PAUSE))
{
/* not perfect but provides a decent compromise */
rb->audio_ff_rewind(elapsed + offset);
rb->audio_resume();
}
else if (status != AUDIO_STATUS_PLAY)
rb->audio_play((unsigned long) elapsed, (unsigned long) offset);
break;
case AUDIO_STOP:
rb->audio_stop();
break;
case AUDIO_PAUSE:
rb->audio_pause();
break;
case AUDIO_RESUME:
rb->audio_resume();
break;
case AUDIO_NEXT:
rb->audio_next();
break;
case AUDIO_PREV:
rb->audio_prev();
break;
case AUDIO_FFREWIND:
newtime = (long) luaL_checkint(L, 2);
rb->audio_ff_rewind(newtime);
break;
case AUDIO_FLUSHANDRELOADTRACKS:
rb->audio_flush_and_reload_tracks();
break;
case AUDIO_GETPOS:
lua_pushinteger(L, rb->audio_get_file_pos());
return 1;
case AUDIO_LENGTH:
if ((status & AUDIO_STATUS_PLAY) == AUDIO_STATUS_PLAY)
lua_pushinteger(L, rb->audio_current_track()->length);
else
lua_pushnil(L);
return 1;
case AUDIO_ELAPSED:
if ((status & AUDIO_STATUS_PLAY) == AUDIO_STATUS_PLAY)
lua_pushinteger(L, rb->audio_current_track()->elapsed);
else
lua_pushnil(L);
return 1;
}
yield();
lua_pushinteger(L, status); /* return previous (or current) audio status */
return 1;
}
RB_WRAP(sound)
{
enum e_snd {SOUND_SET = 0, SOUND_CURRENT, SOUND_DEFAULT,
SOUND_MIN, SOUND_MAX, SOUND_UNIT, SOUND_SET_PITCH,
SOUND_VAL2PHYS, SOUND_ECOUNT};
const char *snd_option[] = {"set", "current", "default",
"min", "max", "unit", "pitch",
"val2phys", NULL};
lua_pushnil(L); /*push nil so options w/o return have something to return */
int option = luaL_checkoption (L, 1, NULL, snd_option);
int setting = luaL_checkint(L, 2);
int value, result;
switch(option)
{
case SOUND_SET:
value = luaL_checkint(L, 3);
rb->sound_set(setting, value);
return 1; /*nil*/
break;
case SOUND_CURRENT:
result = rb->sound_current(setting);
break;
case SOUND_DEFAULT:
result = rb->sound_default(setting);
break;
case SOUND_MIN:
result = rb->sound_min(setting);
break;
case SOUND_MAX:
result = rb->sound_max(setting);
break;
case SOUND_UNIT:
lua_pushstring (L, rb->sound_unit(setting));
return 1;
break;
#if ((CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) || \
(CONFIG_CODEC == SWCODEC)) && defined (HAVE_PITCHCONTROL)
case SOUND_SET_PITCH:
rb->sound_set_pitch(setting);
return 1;/*nil*/
break;
#endif
case SOUND_VAL2PHYS:
value = luaL_checkint(L, 3);
result = rb->sound_val2phys(setting, value);
break;
default:
return 1;
break;
}
lua_pushinteger(L, result);
return 1;
}
#if CONFIG_CODEC == SWCODEC
RB_WRAP(pcm)
{
enum e_pcm {PCM_APPLYSETTINGS = 0, PCM_ISPLAYING, PCM_ISPAUSED,
PCM_PLAYSTOP, PCM_PLAYPAUSE, PCM_PLAYLOCK, PCM_PLAYUNLOCK,
PCM_CALCULATEPEAKS, PCM_SETFREQUENCY, PCM_GETBYTESWAITING, PCM_ECOUNT};
const char *pcm_option[] = {"apply_settings", "is_playing", "is_paused",
"play_stop", "play_pause", "play_lock", "play_unlock",
"calculate_peaks", "set_frequency", "get_bytes_waiting", NULL};
bool b_result;
int left, right;
size_t byteswait;
lua_pushnil(L); /*push nil so options w/o return have something to return */
int option = luaL_checkoption (L, 1, NULL, pcm_option);
switch(option)
{
case PCM_APPLYSETTINGS:
rb->pcm_apply_settings();
break;
case PCM_ISPLAYING:
b_result = rb->pcm_is_playing();
lua_pushboolean(L, b_result);
break;
case PCM_ISPAUSED:
b_result = rb->pcm_is_paused();
lua_pushboolean(L, b_result);
break;
case PCM_PLAYPAUSE:
rb->pcm_play_pause(luaL_checkboolean(L, 2));
break;
case PCM_PLAYSTOP:
rb->pcm_play_stop();
break;
case PCM_PLAYLOCK:
rb->pcm_play_lock();
break;
case PCM_PLAYUNLOCK:
rb->pcm_play_unlock();
break;
case PCM_CALCULATEPEAKS:
rb->pcm_calculate_peaks(&left, &right);
lua_pushinteger(L, left);
lua_pushinteger(L, right);
return 2;
case PCM_SETFREQUENCY:
rb->pcm_set_frequency((unsigned int) luaL_checkint(L, 2));
break;
case PCM_GETBYTESWAITING:
byteswait = rb->pcm_get_bytes_waiting();
lua_pushinteger(L, byteswait);
break;
}
yield();
return 1;
}
RB_WRAP(mixer_frequency)
{
unsigned int result = rb->mixer_get_frequency();
if(!lua_isnoneornil(L, 1))
{
unsigned int samplerate = (unsigned int) luaL_checkint(L, 1);
rb->mixer_set_frequency(samplerate);
}
lua_pushinteger(L, result);
return 1;
}
#endif /*CONFIG_CODEC == SWCODEC*/
/* DEVICE LIGHTING CONTROL */
RB_WRAP(backlight_onoff)
{
bool on = luaL_checkboolean(L, 1);
if(on)
rb->backlight_on();
else
rb->backlight_off();
return 0;
}
SIMPLE_VOID_WRAPPER(backlight_force_on);
SIMPLE_VOID_WRAPPER(backlight_use_settings);
#ifdef HAVE_REMOTE_LCD
SIMPLE_VOID_WRAPPER(remote_backlight_force_on);
SIMPLE_VOID_WRAPPER(remote_backlight_use_settings);
#endif
#ifdef HAVE_BUTTON_LIGHT
SIMPLE_VOID_WRAPPER(buttonlight_force_on);
SIMPLE_VOID_WRAPPER(buttonlight_use_settings);
#endif
#ifdef HAVE_BACKLIGHT_BRIGHTNESS
RB_WRAP(backlight_brightness_set)
{
if(lua_isnoneornil(L, 1))
backlight_brightness_use_setting();
else
{
int brightness = luaL_checkint(L, 1);
backlight_brightness_set(brightness);
}
return 0;
}
#endif
#ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
RB_WRAP(buttonlight_brightness_set)
{
if(lua_isnoneornil(L, 1))
buttonlight_brightness_use_setting();
else
{
int brightness = luaL_checkint(L, 1);
buttonlight_brightness_set(brightness);
}
return 0;
}
#endif
/* DEVICE STRING / FILENAME MANIPULATION */
#if 0 /*See files.lua */
RB_WRAP(strip_extension)
{
const char* filename = luaL_checkstring(L, -1);
const char* pos = rb->strrchr(filename, '.');
if(pos != NULL)
lua_pushlstring (L, filename, pos - filename);
return 1;
}
RB_WRAP(create_numbered_filename)
{
luaL_Buffer b;
luaL_buffinit(L, &b);
char *buffer = luaL_prepbuffer(&b);
buffer[0] = '\0';
const char * path = luaL_checkstring(L, 1);
const char * prefix = luaL_checkstring(L, 2);
const char * suffix = luaL_checkstring(L, 3);
int numberlen = luaL_checkint(L, 4);
int num = luaL_optint(L, 5, -1);
(void) num;
if(rb->create_numbered_filename(buffer, path, prefix, suffix, numberlen
IF_CNFN_NUM_(, &num)))
{
luaL_addstring(&b, buffer);
luaL_pushresult(&b);
}
else
return 0;
return 1;
}
#endif
RB_WRAP(utf8encode)
{
unsigned long ucs = (unsigned long) luaL_checkint(L, 1);
unsigned char tmp[9];
unsigned char *end = rb->utf8encode(ucs, tmp);
*end = '\0';
lua_pushstring(L, tmp);
return 1;
}
RB_WRAP(strncasecmp)
{
int result;
const char * s1 = luaL_checkstring(L, 1);
const char * s2 = luaL_checkstring(L, 2);
if(lua_isnoneornil(L, 3))
result = rb->strcasecmp(s1, s2);
else
result = rb->strncasecmp(s1, s2, (size_t) luaL_checkint(L, 3));
lua_pushinteger(L, result);
return 1;
}
/* ROCKBOX SETTINGS / INFO */
static int mem_read_write(lua_State *L, uintptr_t address, size_t maxsize, bool isstr_p)
{
if(isstr_p) /*pointer to string (**char)*/
{
lua_settop(L, 2); /* no writes allowed */
}
intptr_t offset = (intptr_t) luaL_optnumber(L, 1, 0);
size_t size = (size_t) luaL_optnumber(L, 2, maxsize);
size_t written;
int type = lua_type(L, 3);
if(offset < 0)
{
/* allows pointer within structure to be calculated offset */
offset = -(address + offset);
luaL_argcheck(L, ((size_t) offset) <= maxsize, 1, ERR_IDX_RANGE);
size = (size_t) maxsize - offset;
}
luaL_argcheck(L, ((uintptr_t) offset) + size <= maxsize, 2, ERR_IDX_RANGE);
char *mem = (char*) address + ((uintptr_t) offset);
const void *value = NULL;
lua_Integer var_luaint;
#ifdef UINT64_MAX
int64_t var_64;
#endif
int32_t var_32;
int16_t var_16;
int8_t var_8;
bool var_bool;
switch(type)
{
case LUA_TSTRING:
{
size_t len;
const char* str = lua_tolstring (L, 3, &len);
luaL_argcheck(L, len + 1 <= size, 3, ERR_DATA_OVF);
size = len + 1; /* include \0 */
value = str;
break;
}
case LUA_TBOOLEAN:
{
var_bool = (bool) lua_toboolean(L, 3);
value = &var_bool;
break;
}
case LUA_TNUMBER:
{
var_luaint = lua_tointeger(L, 3);
switch(size)
{
case sizeof(var_8):
var_8 = (int8_t) var_luaint;
value = &var_8;
break;
case sizeof(var_16):
var_16 = (int16_t) var_luaint;
value = &var_16;
break;
case sizeof(var_32):
var_32 = (int32_t) var_luaint;
value = &var_32;
break;
#ifdef UINT64_MAX
case sizeof(var_64):
var_64 = (int64_t) var_luaint;
value = &var_64;
break;
#endif
} /* switch size */
break;
}
case LUA_TNIL:
case LUA_TNONE: /* reader */
{
if(isstr_p && mem)
{
lua_pushstring (L, *(char**) mem);
return 1;
}
luaL_Buffer b;
luaL_buffinit(L, &b);
while(size > 0)
{
written = MIN(LUAL_BUFFERSIZE, size);
luaL_addlstring (&b, mem, written);
mem += written;
size -= written;
}
luaL_pushresult(&b);
return 1;
}
default:
break;
} /* switch type */
/* writer */
luaL_argcheck(L, value != NULL, 3, "Unknown Type");
rb->memcpy(mem, value, size);
lua_pushinteger(L, 1);
return 1;
}
RB_WRAP(global_status)
{
const uintptr_t address = (uintptr_t) rb->global_status;
const size_t maxsize = sizeof(struct system_status);
/*const bool isstr_p = lua_toboolean(L, 4);*/
return mem_read_write(L, address, maxsize, false);
}
RB_WRAP(global_settings)
{
const uintptr_t address = (uintptr_t) rb->global_settings;
const size_t maxsize = sizeof(struct user_settings);
/*const bool isstr_p = lua_toboolean(L, 4);*/
return mem_read_write(L, address, maxsize, false);
}
RB_WRAP(audio_next_track)
{
const uintptr_t address = (uintptr_t) rb->audio_next_track();
const size_t maxsize = sizeof(struct mp3entry);
const bool isstr_p = lua_toboolean(L, 4);
lua_settop(L, 2); /* no writes allowed */
return mem_read_write(L, address, maxsize, isstr_p);
}
RB_WRAP(audio_current_track)
{
const uintptr_t address = (uintptr_t) rb->audio_current_track();
const size_t maxsize = sizeof(struct mp3entry);
const bool isstr_p = lua_toboolean(L, 4);
lua_settop(L, 2); /* no writes allowed */
return mem_read_write(L, address, maxsize, isstr_p);
}
RB_WRAP(settings_save)
{
rb->settings_save();
return 0;
}
#if 0
RB_WRAP(read_mem)
{
lua_settop(L, 2); /* no writes allowed */
const uintptr_t address = lua_tonumber(L, 1);
const size_t maxsize = luaL_optnumber(L, 2, strlen((char *)address));
luaL_argcheck(L, address > 0, 1, ERR_IDX_RANGE);
lua_pushnil(L);
lua_replace(L, -3);/* stk pos 1 is no longer offset it is starting address */
return mem_read_write(L, address, maxsize, false);
}
/* will add this back if anyone finds a target that needs it */
RB_WRAP(system_memory_guard)
{
int newmode = (int) luaL_checkint(L, 1);
int result = rb->system_memory_guard(newmode);
lua_pushinteger(L, result);
return 1;
}
#endif
/* SPEAKING */
static int rock_talk(lua_State *L)
{
int result;
bool enqueue = lua_toboolean(L, 2);
if (lua_isnumber(L, 1))
{
long n = (long) lua_tonumber(L, 1);
result = rb->talk_number(n, enqueue);
}
else
{
const char* spell = luaL_checkstring(L, 1);
result = rb->talk_spell(spell, enqueue);
}
lua_pushinteger(L, result);
return 1;
}
RB_WRAP(talk_shutup)
{
if (lua_toboolean(L, 1))
rb->talk_force_shutup();
else
rb->talk_shutup();
return 0;
}
/* MISC */
RB_WRAP(restart_lua)
{
/*close lua state, open a new lua state, load script @ filename */
luaL_checktype (L, 1, LUA_TSTRING);
lua_settop(L, 1);
lua_pushlightuserdata(L, L); /* signal exit handler */
exit(1); /* atexit in rocklua.c */
return -1;
}
RB_WRAP(show_logo)
{
rb->show_logo();
return 0;
}
#define RB_FUNC(func) {#func, rock_##func}
#define RB_ALIAS(name, func) {name, rock_##func}
static const luaL_Reg rocklib[] =
{
/* KERNEL */
RB_FUNC(current_tick),
#ifdef HAVE_SCHEDULER_BOOSTCTRL
RB_FUNC(schedule_cpu_boost),
#endif
RB_FUNC(sleep),
#ifdef HAVE_PRIORITY_SCHEDULING
RB_FUNC(thread_set_priority),
#endif
RB_FUNC(current_path),
/* DEVICE INPUT CONTROL */
RB_FUNC(get_plugin_action),
#ifdef HAVE_TOUCHSCREEN
RB_FUNC(action_get_touchscreen_press),
RB_FUNC(touchscreen_mode),
#endif
RB_FUNC(kbd_input),
RB_FUNC(gui_syncyesno_run),
RB_FUNC(do_menu),
/* DEVICE AUDIO / SOUND / PLAYLIST CONTROL */
RB_FUNC(audio),
RB_FUNC(playlist),
RB_FUNC(sound),
#if CONFIG_CODEC == SWCODEC
RB_FUNC(pcm),
RB_FUNC(mixer_frequency),
#endif
/* DEVICE LIGHTING CONTROL */
RB_FUNC(backlight_onoff),
/* Backlight helper */
RB_FUNC(backlight_force_on),
RB_FUNC(backlight_use_settings),
#ifdef HAVE_REMOTE_LCD
RB_FUNC(remote_backlight_force_on),
RB_FUNC(remote_backlight_use_settings),
#endif
#ifdef HAVE_BUTTON_LIGHT
RB_FUNC(buttonlight_force_on),
RB_FUNC(buttonlight_use_settings),
#endif
#ifdef HAVE_BACKLIGHT_BRIGHTNESS
RB_FUNC(backlight_brightness_set),
#endif
#ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
RB_FUNC(buttonlight_brightness_set),
#endif
/* DEVICE STRING / FILENAME MANIPULATION */
#if 0 /*See files.lua */
RB_FUNC(strip_extension),
RB_FUNC(create_numbered_filename),
#endif
RB_FUNC(utf8encode),
RB_FUNC(strncasecmp),
/* ROCKBOX SETTINGS / INFO */
RB_FUNC(global_status),
RB_FUNC(global_settings),
RB_FUNC(audio_next_track),
RB_FUNC(audio_current_track),
RB_FUNC(settings_save),
/* SPEAKING */
{"talk_number", rock_talk},
{"talk_spell", rock_talk},
RB_FUNC(talk_shutup),
/* MISC */
RB_FUNC(restart_lua),
RB_FUNC(show_logo),
{NULL, NULL}
};
#undef RB_FUNC
#undef RB_ALIAS
extern const luaL_Reg rocklib_aux[];
/*
** Open Rockbox library
*/
LUALIB_API int luaopen_rock(lua_State *L)
{
luaL_register(L, LUA_ROCKLIBNAME, rocklib);
luaL_register(L, LUA_ROCKLIBNAME, rocklib_aux);
lua_getglobal(L, "require");
lua_pushstring(L, "rb_defines");
if (lua_pcall (L, 1, 0, 0))
lua_pop(L, 1);
#if 0 /* see rb_defines.lua */
static const struct lua_int_reg rlib_const_int[] =
{
/* useful integer constants */
RB_CONSTANT(HZ),
RB_CONSTANT(LCD_DEPTH),
RB_CONSTANT(LCD_HEIGHT),
RB_CONSTANT(LCD_WIDTH),
RB_CONSTANT(SCREEN_MAIN),
#if LCD_DEPTH > 1
RB_CONSTANT(LCD_DEFAULT_FG),
RB_CONSTANT(LCD_DEFAULT_BG),
#endif
#ifdef HAVE_REMOTE_LCD
RB_CONSTANT(LCD_REMOTE_DEPTH),
RB_CONSTANT(LCD_REMOTE_HEIGHT),
RB_CONSTANT(LCD_REMOTE_WIDTH),
RB_CONSTANT(SCREEN_REMOTE),
#endif
RB_CONSTANT(FONT_SYSFIXED),
RB_CONSTANT(FONT_UI),
RB_CONSTANT(PLAYLIST_INSERT),
RB_CONSTANT(PLAYLIST_INSERT_LAST),
RB_CONSTANT(PLAYLIST_INSERT_FIRST),
RB_CONSTANT(PLAYLIST_INSERT_LAST_SHUFFLED),
RB_CONSTANT(PLAYLIST_INSERT_SHUFFLED),
RB_CONSTANT(PLAYLIST_PREPEND),
RB_CONSTANT(PLAYLIST_REPLACE),
/* queue sys events */
RB_CONSTANT(SYS_USB_CONNECTED),
RB_CONSTANT(SYS_USB_DISCONNECTED),
RB_CONSTANT(SYS_TIMEOUT),
RB_CONSTANT(SYS_POWEROFF),
RB_CONSTANT(SYS_CHARGER_CONNECTED),
RB_CONSTANT(SYS_CHARGER_DISCONNECTED),
#ifdef HAVE_TOUCHSCREEN
RB_CONSTANT(TOUCHSCREEN_POINT),
RB_CONSTANT(TOUCHSCREEN_BUTTON),
#endif
{NULL, 0}
};
static const struct lua_int_reg* rlci = rlib_const_int;
for (; rlci->name; rlci++) {
lua_pushinteger(L, rlci->value);
luaS_newlloc(L, rlci->name, TSTR_INBIN);
lua_setfield(L, -2, rlci->name);
}
static const struct lua_str_reg rlib_const_str[] =
{
/* some useful paths constants */
RB_STRING_CONSTANT(HOME_DIR),
RB_STRING_CONSTANT(PLUGIN_DIR),
RB_STRING_CONSTANT(PLUGIN_APPS_DATA_DIR),
RB_STRING_CONSTANT(PLUGIN_GAMES_DATA_DIR),
RB_STRING_CONSTANT(PLUGIN_DATA_DIR),
RB_STRING_CONSTANT(ROCKBOX_DIR),
RB_STRING_CONSTANT(VIEWERS_DATA_DIR),
{NULL,NULL}
};
static const struct lua_str_reg* rlcs = rlib_const_str;
for (; rlcs->name; rlcs++) {
luaS_newlloc(L, rlcs->value, TSTR_INBIN);
lua_pushstring(L, rlcs->value);
luaS_newlloc(L, rlcs->name, TSTR_INBIN);
lua_setfield(L, -2, rlcs->name);
}
#endif
return 1;
}