apps/plugins/lua/rocklib.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2008 Dan Everton (safetydan)
  11  * Copyright (C) 2009 Maurus Cuelenaere
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22
  23 #define lrocklib_c
  24 #define LUA_LIB
  25
  26 #include "lua.h"
  27
  28 #include "lauxlib.h"
  29 #include "rocklib.h"
  30
  31 /*
  32  * http://www.lua.org/manual/5.1/manual.html#lua_CFunction
  33  *
  34  * In order to communicate properly with Lua, a C function must use the following protocol,
  35  * which defines the way parameters and results are passed: a C function receives its arguments
  36  * from Lua in its stack in direct order (the first argument is pushed first). To return values to Lua,
  37  * a C function just pushes them onto the stack, in direct order (the first result is pushed first),
  38  * and returns the number of results. Any other value in the stack below the results will be properly
  39  * discarded by Lua. Like a Lua function, a C function called by Lua can also return many results.
  40  */
  41
  42
  43 /*
  44  * -----------------------------
  45  *
  46  *  Rockbox Lua image wrapper
  47  *
  48  * -----------------------------
  49  */
  50
  51 #define ROCKLUA_IMAGE "rb.image"
  52 struct rocklua_image
  53 {
  54     int width;
  55     int height;
  56     fb_data *data;
  57     fb_data dummy[1][1];
  58 };
  59
  60 static void rli_wrap(lua_State *L, fb_data *src, int width, int height)
  61 {
  62     struct rocklua_image *a = (struct rocklua_image *)lua_newuserdata(L, sizeof(struct rocklua_image));
  63
  64     luaL_getmetatable(L, ROCKLUA_IMAGE);
  65     lua_setmetatable(L, -2);
  66
  67     a->width = width;
  68     a->height = height;
  69     a->data = src;
  70 }
  71
  72 static fb_data* rli_alloc(lua_State *L, int width, int height)
  73 {
  74     size_t nbytes = sizeof(struct rocklua_image) + ((width*height) - 1) * sizeof(fb_data);
  75     struct rocklua_image *a = (struct rocklua_image *)lua_newuserdata(L, nbytes);
  76
  77     luaL_getmetatable(L, ROCKLUA_IMAGE);
  78     lua_setmetatable(L, -2);
  79
  80     a->width = width;
  81     a->height = height;
  82     a->data = &a->dummy[0][0];
  83
  84     return a->data;
  85 }
  86
  87 static int rli_new(lua_State *L)
  88 {
  89     int width = luaL_checkint(L, 1);
  90     int height = luaL_checkint(L, 2);
  91
  92     rli_alloc(L, width, height);
  93
  94     return 1;
  95 }
  96
  97 static struct rocklua_image* rli_checktype(lua_State *L, int arg)
  98 {
  99     void *ud = luaL_checkudata(L, arg, ROCKLUA_IMAGE);
 100     luaL_argcheck(L, ud != NULL, arg, "'" ROCKLUA_IMAGE "' expected");
 101     return (struct rocklua_image*) ud;
 102 }
 103
 104 static int rli_width(lua_State *L)
 105 {
 106     struct rocklua_image *a = rli_checktype(L, 1);
 107     lua_pushnumber(L, a->width);
 108     return 1;
 109 }
 110
 111 static int rli_height(lua_State *L)
 112 {
 113     struct rocklua_image *a = rli_checktype(L, 1);
 114     lua_pushnumber(L, a->height);
 115     return 1;
 116 }
 117
 118 static fb_data* rli_element(lua_State *L)
 119 {
 120     struct rocklua_image *a = rli_checktype(L, 1);
 121     int x = luaL_checkint(L, 2);
 122     int y = luaL_checkint(L, 3);
 123
 124     luaL_argcheck(L, 1 <= x && x <= a->width, 2,
 125                     "index out of range");
 126     luaL_argcheck(L, 1 <= y && y <= a->height, 3,
 127                     "index out of range");
 128
 129     /* return element address */
 130     return &a->data[a->width * (y - 1) + (x - 1)];
 131 }
 132
 133 static int rli_set(lua_State *L)
 134 {
 135     fb_data newvalue = (fb_data) luaL_checknumber(L, 4);
 136     *rli_element(L) = newvalue;
 137     return 0;
 138 }
 139
 140 static int rli_get(lua_State *L)
 141 {
 142     lua_pushnumber(L, *rli_element(L));
 143     return 1;
 144 }
 145
 146 static int rli_tostring(lua_State *L)
 147 {
 148     struct rocklua_image *a = rli_checktype(L, 1);
 149     lua_pushfstring(L, ROCKLUA_IMAGE ": %dx%d", a->width, a->height);
 150     return 1;
 151 }
 152
 153 static const struct luaL_reg rli_lib [] =
 154 {
 155     {"__tostring", rli_tostring},
 156     {"set", rli_set},
 157     {"get", rli_get},
 158     {"width", rli_width},
 159     {"height", rli_height},
 160     {NULL, NULL}
 161 };
 162
 163 static inline void rli_init(lua_State *L)
 164 {
 165     luaL_newmetatable(L, ROCKLUA_IMAGE);
 166
 167     lua_pushstring(L, "__index");
 168     lua_pushvalue(L, -2);  /* pushes the metatable */
 169     lua_settable(L, -3);  /* metatable.__index = metatable */
 170
 171     luaL_register(L, NULL, rli_lib);
 172 }
 173
 174 /*
 175  * -----------------------------
 176  *
 177  *  Rockbox wrappers start here!
 178  *
 179  * -----------------------------
 180  */
 181
 182 #define RB_WRAP(M) static int rock_##M(lua_State *L)
 183
 184 /* Helper function for opt_viewport */
 185 static void check_tablevalue(lua_State *L, const char* key, int tablepos, void* res, bool unsigned_val)
 186 {
 187     lua_getfield(L, tablepos, key); /* Find table[key] */
 188
 189     if(!lua_isnoneornil(L, -1))
 190     {
 191         if(unsigned_val)
 192             *(unsigned*)res = luaL_checkint(L, -1);
 193         else
 194             *(int*)res = luaL_checkint(L, -1);
 195     }
 196
 197     lua_pop(L, 1); /* Pop the value off the stack */
 198 }
 199
 200 static struct viewport* opt_viewport(lua_State *L, int narg, struct viewport* alt)
 201 {
 202     if(lua_isnoneornil(L, narg))
 203         return alt;
 204
 205     int tablepos = lua_gettop(L);
 206     struct viewport *vp;
 207
 208     lua_getfield(L, tablepos, "vp");  /* get table['vp'] */
 209     if(lua_isnoneornil(L, -1))
 210     {
 211         lua_pop(L, 1); /* Pop nil off stack */
 212
 213         vp = (struct viewport*) lua_newuserdata(L, sizeof(struct viewport)); /* Allocate memory and push it as udata on the stack */
 214         memset(vp, 0, sizeof(struct viewport)); /* Init viewport values to 0 */
 215         lua_setfield(L, tablepos, "vp"); /* table['vp'] = vp (pops value off the stack) */
 216     }
 217     else
 218     {
 219         vp = (struct viewport*) lua_touserdata(L, -1); /* Reuse viewport struct */
 220         lua_pop(L, 1); /* We don't need the value on stack */
 221     }
 222
 223     luaL_checktype(L, narg, LUA_TTABLE);
 224
 225     check_tablevalue(L, "x", tablepos, &vp->x, false);
 226     check_tablevalue(L, "y", tablepos, &vp->y, false);
 227     check_tablevalue(L, "width", tablepos, &vp->width, false);
 228     check_tablevalue(L, "height", tablepos, &vp->height, false);
 229 #ifdef HAVE_LCD_BITMAP
 230     check_tablevalue(L, "font", tablepos, &vp->font, false);
 231     check_tablevalue(L, "drawmode", tablepos, &vp->drawmode, false);
 232 #endif
 233 #if LCD_DEPTH > 1
 234     check_tablevalue(L, "fg_pattern", tablepos, &vp->fg_pattern, true);
 235     check_tablevalue(L, "bg_pattern", tablepos, &vp->bg_pattern, true);
 236 #ifdef HAVE_LCD_COLOR
 237     check_tablevalue(L, "lss_pattern", tablepos, &vp->lss_pattern, true);
 238     check_tablevalue(L, "lse_pattern", tablepos, &vp->lse_pattern, true);
 239     check_tablevalue(L, "lst_pattern", tablepos, &vp->lst_pattern, true);
 240 #endif
 241 #endif
 242
 243     return vp;
 244 }
 245
 246 RB_WRAP(set_viewport)
 247 {
 248     struct viewport *vp = opt_viewport(L, 1, NULL);
 249     int screen = luaL_optint(L, 2, SCREEN_MAIN);
 250     rb->screens[screen]->set_viewport(vp);
 251     return 0;
 252 }
 253
 254 RB_WRAP(clear_viewport)
 255 {
 256     int screen = luaL_optint(L, 1, SCREEN_MAIN);
 257     rb->screens[screen]->clear_viewport();
 258     return 0;
 259 }
 260
 261 #ifdef HAVE_LCD_BITMAP
 262 RB_WRAP(lcd_framebuffer)
 263 {
 264     rli_wrap(L, rb->lcd_framebuffer, LCD_WIDTH, LCD_HEIGHT);
 265     return 1;
 266 }
 267
 268 RB_WRAP(lcd_mono_bitmap_part)
 269 {
 270     struct rocklua_image *src = rli_checktype(L, 1);
 271     int src_x = luaL_checkint(L, 2);
 272     int src_y = luaL_checkint(L, 3);
 273     int stride = luaL_checkint(L, 4);
 274     int x = luaL_checkint(L, 5);
 275     int y = luaL_checkint(L, 6);
 276     int width = luaL_checkint(L, 7);
 277     int height = luaL_checkint(L, 8);
 278
 279     rb->lcd_mono_bitmap_part((const unsigned char *)src->data, src_x, src_y, stride, x, y, width, height);
 280     return 0;
 281 }
 282
 283 RB_WRAP(lcd_mono_bitmap)
 284 {
 285     struct rocklua_image *src = rli_checktype(L, 1);
 286     int x = luaL_checkint(L, 2);
 287     int y = luaL_checkint(L, 3);
 288     int width = luaL_checkint(L, 4);
 289     int height = luaL_checkint(L, 5);
 290
 291     rb->lcd_mono_bitmap((const unsigned char *)src->data, x, y, width, height);
 292     return 0;
 293 }
 294
 295 #if LCD_DEPTH > 1
 296 RB_WRAP(lcd_bitmap_part)
 297 {
 298     struct rocklua_image *src = rli_checktype(L, 1);
 299     int src_x = luaL_checkint(L, 2);
 300     int src_y = luaL_checkint(L, 3);
 301     int stride = luaL_checkint(L, 4);
 302     int x = luaL_checkint(L, 5);
 303     int y = luaL_checkint(L, 6);
 304     int width = luaL_checkint(L, 7);
 305     int height = luaL_checkint(L, 8);
 306
 307     rb->lcd_bitmap_part(src->data, src_x, src_y, stride, x, y, width, height);
 308     return 0;
 309 }
 310
 311 RB_WRAP(lcd_bitmap)
 312 {
 313     struct rocklua_image *src = rli_checktype(L, 1);
 314     int x = luaL_checkint(L, 2);
 315     int y = luaL_checkint(L, 3);
 316     int width = luaL_checkint(L, 4);
 317     int height = luaL_checkint(L, 5);
 318
 319     rb->lcd_bitmap(src->data, x, y, width, height);
 320     return 0;
 321 }
 322
 323 RB_WRAP(lcd_get_backdrop)
 324 {
 325     fb_data* backdrop = rb->lcd_get_backdrop();
 326     if(backdrop == NULL)
 327         return 0;
 328     else
 329     {
 330         rli_wrap(L, backdrop, LCD_WIDTH, LCD_HEIGHT);
 331         return 1;
 332     }
 333 }
 334 #endif /* LCD_DEPTH > 1 */
 335
 336 #if LCD_DEPTH == 16
 337 RB_WRAP(lcd_bitmap_transparent_part)
 338 {
 339     struct rocklua_image *src = rli_checktype(L, 1);
 340     int src_x = luaL_checkint(L, 2);
 341     int src_y = luaL_checkint(L, 3);
 342     int stride = luaL_checkint(L, 4);
 343     int x = luaL_checkint(L, 5);
 344     int y = luaL_checkint(L, 6);
 345     int width = luaL_checkint(L, 7);
 346     int height = luaL_checkint(L, 8);
 347
 348     rb->lcd_bitmap_transparent_part(src->data, src_x, src_y, stride, x, y, width, height);
 349     return 0;
 350 }
 351
 352 RB_WRAP(lcd_bitmap_transparent)
 353 {
 354     struct rocklua_image *src = rli_checktype(L, 1);
 355     int x = luaL_checkint(L, 2);
 356     int y = luaL_checkint(L, 3);
 357     int width = luaL_checkint(L, 4);
 358     int height = luaL_checkint(L, 5);
 359
 360     rb->lcd_bitmap_transparent(src->data, x, y, width, height);
 361     return 0;
 362 }
 363 #endif /* LCD_DEPTH == 16 */
 364
 365 #endif /* defined(LCD_BITMAP) */
 366
 367 RB_WRAP(current_tick)
 368 {
 369     lua_pushinteger(L, *rb->current_tick);
 370     return 1;
 371 }
 372
 373 #ifdef HAVE_TOUCHSCREEN
 374 RB_WRAP(action_get_touchscreen_press)
 375 {
 376     short x, y;
 377     int result = rb->action_get_touchscreen_press(&x, &y);
 378
 379     lua_pushinteger(L, result);
 380     lua_pushinteger(L, x);
 381     lua_pushinteger(L, y);
 382     return 3;
 383 }
 384 #endif
 385
 386 RB_WRAP(kbd_input)
 387 {
 388     luaL_Buffer b;
 389     luaL_buffinit(L, &b);
 390
 391     char *buffer = luaL_prepbuffer(&b);
 392     buffer[0] = '\0';
 393     rb->kbd_input(buffer, LUAL_BUFFERSIZE);
 394     luaL_addsize(&b, strlen(buffer));
 395
 396     luaL_pushresult(&b);
 397     return 1;
 398 }
 399
 400 #ifdef HAVE_TOUCHSCREEN
 401 RB_WRAP(touchscreen_set_mode)
 402 {
 403     enum touchscreen_mode mode = luaL_checkint(L, 1);
 404     rb->touchscreen_set_mode(mode);
 405     return 0;
 406 }
 407 #endif
 408
 409 RB_WRAP(font_getstringsize)
 410 {
 411     const unsigned char* str = luaL_checkstring(L, 1);
 412     int fontnumber = luaL_checkint(L, 2);
 413     int w, h;
 414
 415     int result = rb->font_getstringsize(str, &w, &h, fontnumber);
 416     lua_pushinteger(L, result);
 417     lua_pushinteger(L, w);
 418     lua_pushinteger(L, h);
 419
 420     return 3;
 421 }
 422
 423 #ifdef HAVE_LCD_COLOR
 424 RB_WRAP(lcd_rgbpack)
 425 {
 426     int r = luaL_checkint(L, 1);
 427     int g = luaL_checkint(L, 2);
 428     int b = luaL_checkint(L, 3);
 429     int result = LCD_RGBPACK(r, g, b);
 430     lua_pushinteger(L, result);
 431     return 1;
 432 }
 433
 434 RB_WRAP(lcd_rgbunpack)
 435 {
 436     int rgb = luaL_checkint(L, 1);
 437     lua_pushinteger(L, RGB_UNPACK_RED(rgb));
 438     lua_pushinteger(L, RGB_UNPACK_GREEN(rgb));
 439     lua_pushinteger(L, RGB_UNPACK_BLUE(rgb));
 440     return 3;
 441 }
 442 #endif
 443
 444 RB_WRAP(read_bmp_file)
 445 {
 446     struct bitmap bm;
 447     const char* filename = luaL_checkstring(L, 1);
 448     bool dither = luaL_optboolean(L, 2, true);
 449     bool transparent = luaL_optboolean(L, 3, false);
 450     int format = FORMAT_NATIVE;
 451
 452     if(dither)
 453         format |= FORMAT_DITHER;
 454
 455     if(transparent)
 456         format |= FORMAT_TRANSPARENT;
 457
 458     int result = rb->read_bmp_file(filename, &bm, 0, format | FORMAT_RETURN_SIZE, NULL);
 459
 460     if(result > 0)
 461     {
 462         bm.data = (unsigned char*) rli_alloc(L, bm.width, bm.height);
 463         rb->read_bmp_file(filename, &bm, result, format, NULL);
 464
 465         return 1;
 466     }
 467
 468     return 0;
 469 }
 470
 471 RB_WRAP(current_path)
 472 {
 473     const char *current_path = get_current_path(L, 1);
 474     if(current_path != NULL)
 475     {
 476         lua_pushstring(L, current_path);
 477         return 1;
 478     }
 479     else
 480         return 0;
 481 }
 482
 483 #define R(NAME) {#NAME, rock_##NAME}
 484 static const luaL_Reg rocklib[] =
 485 {
 486     /* Graphics */
 487 #ifdef HAVE_LCD_BITMAP
 488     R(lcd_framebuffer),
 489     R(lcd_mono_bitmap_part),
 490     R(lcd_mono_bitmap),
 491 #if LCD_DEPTH > 1
 492     R(lcd_get_backdrop),
 493     R(lcd_bitmap_part),
 494     R(lcd_bitmap),
 495 #endif
 496 #if LCD_DEPTH == 16
 497     R(lcd_bitmap_transparent_part),
 498     R(lcd_bitmap_transparent),
 499 #endif
 500 #endif
 501 #ifdef HAVE_LCD_COLOR
 502     R(lcd_rgbpack),
 503     R(lcd_rgbunpack),
 504 #endif
 505
 506     /* Kernel */
 507     R(current_tick),
 508
 509     /* Buttons */
 510 #ifdef HAVE_TOUCHSCREEN
 511     R(action_get_touchscreen_press),
 512     R(touchscreen_set_mode),
 513 #endif
 514     R(kbd_input),
 515
 516     R(font_getstringsize),
 517     R(read_bmp_file),
 518     R(set_viewport),
 519     R(clear_viewport),
 520     R(current_path),
 521
 522     {"new_image", rli_new},
 523
 524     {NULL, NULL}
 525 };
 526 #undef  R
 527 extern const luaL_Reg rocklib_aux[];
 528
 529
 530 #define RB_CONSTANT(x) lua_pushinteger(L, x); lua_setfield(L, -2, #x);
 531 /*
 532  ** Open Rockbox library
 533  */
 534 LUALIB_API int luaopen_rock(lua_State *L)
 535 {
 536     luaL_register(L, LUA_ROCKLIBNAME, rocklib);
 537     luaL_register(L, LUA_ROCKLIBNAME, rocklib_aux);
 538
 539     RB_CONSTANT(HZ);
 540
 541     RB_CONSTANT(LCD_WIDTH);
 542     RB_CONSTANT(LCD_HEIGHT);
 543
 544     RB_CONSTANT(FONT_SYSFIXED);
 545     RB_CONSTANT(FONT_UI);
 546
 547 #ifdef HAVE_TOUCHSCREEN
 548     RB_CONSTANT(TOUCHSCREEN_POINT);
 549     RB_CONSTANT(TOUCHSCREEN_BUTTON);
 550 #endif
 551
 552     rli_init(L);
 553
 554     return 1;
 555 }