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     int screen = luaL_optint(L, 9, SCREEN_MAIN);
 279
 280     rb->screens[screen]->mono_bitmap_part((const unsigned char *)src->data, src_x, src_y, stride, x, y, width, height);
 281     return 0;
 282 }
 283
 284 RB_WRAP(lcd_mono_bitmap)
 285 {
 286     struct rocklua_image *src = rli_checktype(L, 1);
 287     int x = luaL_checkint(L, 2);
 288     int y = luaL_checkint(L, 3);
 289     int width = luaL_checkint(L, 4);
 290     int height = luaL_checkint(L, 5);
 291     int screen = luaL_optint(L, 6, SCREEN_MAIN);
 292
 293     rb->screens[screen]->mono_bitmap((const unsigned char *)src->data, x, y, width, height);
 294     return 0;
 295 }
 296
 297 #if LCD_DEPTH > 1
 298 RB_WRAP(lcd_bitmap_part)
 299 {
 300     struct rocklua_image *src = rli_checktype(L, 1);
 301     int src_x = luaL_checkint(L, 2);
 302     int src_y = luaL_checkint(L, 3);
 303     int stride = luaL_checkint(L, 4);
 304     int x = luaL_checkint(L, 5);
 305     int y = luaL_checkint(L, 6);
 306     int width = luaL_checkint(L, 7);
 307     int height = luaL_checkint(L, 8);
 308     int screen = luaL_optint(L, 9, SCREEN_MAIN);
 309
 310     rb->screens[screen]->bitmap_part(src->data, src_x, src_y, stride, x, y, width, height);
 311     return 0;
 312 }
 313
 314 RB_WRAP(lcd_bitmap)
 315 {
 316     struct rocklua_image *src = rli_checktype(L, 1);
 317     int x = luaL_checkint(L, 2);
 318     int y = luaL_checkint(L, 3);
 319     int width = luaL_checkint(L, 4);
 320     int height = luaL_checkint(L, 5);
 321     int screen = luaL_optint(L, 6, SCREEN_MAIN);
 322
 323     rb->screens[screen]->bitmap(src->data, x, y, width, height);
 324     return 0;
 325 }
 326
 327 RB_WRAP(lcd_get_backdrop)
 328 {
 329     fb_data* backdrop = rb->lcd_get_backdrop();
 330     if(backdrop == NULL)
 331         return 0;
 332     else
 333     {
 334         rli_wrap(L, backdrop, LCD_WIDTH, LCD_HEIGHT);
 335         return 1;
 336     }
 337 }
 338 #endif /* LCD_DEPTH > 1 */
 339
 340 #if LCD_DEPTH == 16
 341 RB_WRAP(lcd_bitmap_transparent_part)
 342 {
 343     struct rocklua_image *src = rli_checktype(L, 1);
 344     int src_x = luaL_checkint(L, 2);
 345     int src_y = luaL_checkint(L, 3);
 346     int stride = luaL_checkint(L, 4);
 347     int x = luaL_checkint(L, 5);
 348     int y = luaL_checkint(L, 6);
 349     int width = luaL_checkint(L, 7);
 350     int height = luaL_checkint(L, 8);
 351     int screen = luaL_optint(L, 9, SCREEN_MAIN);
 352
 353     rb->screens[screen]->transparent_bitmap_part(src->data, src_x, src_y, stride, x, y, width, height);
 354     return 0;
 355 }
 356
 357 RB_WRAP(lcd_bitmap_transparent)
 358 {
 359     struct rocklua_image *src = rli_checktype(L, 1);
 360     int x = luaL_checkint(L, 2);
 361     int y = luaL_checkint(L, 3);
 362     int width = luaL_checkint(L, 4);
 363     int height = luaL_checkint(L, 5);
 364     int screen = luaL_optint(L, 6, SCREEN_MAIN);
 365
 366     rb->screens[screen]->transparent_bitmap(src->data, x, y, width, height);
 367     return 0;
 368 }
 369 #endif /* LCD_DEPTH == 16 */
 370
 371 #endif /* defined(LCD_BITMAP) */
 372
 373 RB_WRAP(current_tick)
 374 {
 375     lua_pushinteger(L, *rb->current_tick);
 376     return 1;
 377 }
 378
 379 #ifdef HAVE_TOUCHSCREEN
 380 RB_WRAP(action_get_touchscreen_press)
 381 {
 382     short x, y;
 383     int result = rb->action_get_touchscreen_press(&x, &y);
 384
 385     lua_pushinteger(L, result);
 386     lua_pushinteger(L, x);
 387     lua_pushinteger(L, y);
 388     return 3;
 389 }
 390 #endif
 391
 392 RB_WRAP(kbd_input)
 393 {
 394     luaL_Buffer b;
 395     luaL_buffinit(L, &b);
 396
 397     char *buffer = luaL_prepbuffer(&b);
 398     buffer[0] = '\0';
 399     rb->kbd_input(buffer, LUAL_BUFFERSIZE);
 400     luaL_addsize(&b, strlen(buffer));
 401
 402     luaL_pushresult(&b);
 403     return 1;
 404 }
 405
 406 #ifdef HAVE_TOUCHSCREEN
 407 RB_WRAP(touchscreen_set_mode)
 408 {
 409     enum touchscreen_mode mode = luaL_checkint(L, 1);
 410     rb->touchscreen_set_mode(mode);
 411     return 0;
 412 }
 413 #endif
 414
 415 RB_WRAP(font_getstringsize)
 416 {
 417     const unsigned char* str = luaL_checkstring(L, 1);
 418     int fontnumber = luaL_checkint(L, 2);
 419     int w, h;
 420
 421     int result = rb->font_getstringsize(str, &w, &h, fontnumber);
 422     lua_pushinteger(L, result);
 423     lua_pushinteger(L, w);
 424     lua_pushinteger(L, h);
 425
 426     return 3;
 427 }
 428
 429 #ifdef HAVE_LCD_COLOR
 430 RB_WRAP(lcd_rgbpack)
 431 {
 432     int r = luaL_checkint(L, 1);
 433     int g = luaL_checkint(L, 2);
 434     int b = luaL_checkint(L, 3);
 435     int result = LCD_RGBPACK(r, g, b);
 436     lua_pushinteger(L, result);
 437     return 1;
 438 }
 439
 440 RB_WRAP(lcd_rgbunpack)
 441 {
 442     int rgb = luaL_checkint(L, 1);
 443     lua_pushinteger(L, RGB_UNPACK_RED(rgb));
 444     lua_pushinteger(L, RGB_UNPACK_GREEN(rgb));
 445     lua_pushinteger(L, RGB_UNPACK_BLUE(rgb));
 446     return 3;
 447 }
 448 #endif
 449
 450 RB_WRAP(read_bmp_file)
 451 {
 452     struct bitmap bm;
 453     const char* filename = luaL_checkstring(L, 1);
 454     bool dither = luaL_optboolean(L, 2, true);
 455     bool transparent = luaL_optboolean(L, 3, false);
 456     int format = FORMAT_NATIVE;
 457
 458     if(dither)
 459         format |= FORMAT_DITHER;
 460
 461     if(transparent)
 462         format |= FORMAT_TRANSPARENT;
 463
 464     int result = rb->read_bmp_file(filename, &bm, 0, format | FORMAT_RETURN_SIZE, NULL);
 465
 466     if(result > 0)
 467     {
 468         bm.data = (unsigned char*) rli_alloc(L, bm.width, bm.height);
 469         rb->read_bmp_file(filename, &bm, result, format, NULL);
 470
 471         return 1;
 472     }
 473
 474     return 0;
 475 }
 476
 477 RB_WRAP(current_path)
 478 {
 479     const char *current_path = get_current_path(L, 1);
 480     if(current_path != NULL)
 481     {
 482         lua_pushstring(L, current_path);
 483         return 1;
 484     }
 485     else
 486         return 0;
 487 }
 488
 489 static void fill_text_message(lua_State *L, struct text_message * message,
 490                               int pos)
 491 {
 492     int i;
 493     luaL_checktype(L, pos, LUA_TTABLE);
 494     int n = luaL_getn(L, pos);
 495     const char **lines = (const char**) dlmalloc(n * sizeof(const char*));
 496     for(i=1; i<=n; i++)
 497     {
 498         lua_rawgeti(L, pos, i);
 499         lines[i-1] = luaL_checkstring(L, -1);
 500         lua_pop(L, 1);
 501     }
 502     message->message_lines = lines;
 503     message->nb_lines = n;
 504 }
 505
 506 RB_WRAP(gui_syncyesno_run)
 507 {
 508     struct text_message main_message, yes_message, no_message;
 509     struct text_message *yes = NULL, *no = NULL;
 510
 511     fill_text_message(L, &main_message, 1);
 512     if(!lua_isnoneornil(L, 2))
 513         fill_text_message(L, (yes = &yes_message), 2);
 514     if(!lua_isnoneornil(L, 3))
 515         fill_text_message(L, (no = &no_message), 3);
 516
 517     enum yesno_res result = rb->gui_syncyesno_run(&main_message, yes, no);
 518
 519     dlfree(main_message.message_lines);
 520     if(yes)
 521         dlfree(yes_message.message_lines);
 522     if(no)
 523         dlfree(no_message.message_lines);
 524
 525     lua_pushinteger(L, result);
 526     return 1;
 527 }
 528
 529 #define R(NAME) {#NAME, rock_##NAME}
 530 static const luaL_Reg rocklib[] =
 531 {
 532     /* Graphics */
 533 #ifdef HAVE_LCD_BITMAP
 534     R(lcd_framebuffer),
 535     R(lcd_mono_bitmap_part),
 536     R(lcd_mono_bitmap),
 537 #if LCD_DEPTH > 1
 538     R(lcd_get_backdrop),
 539     R(lcd_bitmap_part),
 540     R(lcd_bitmap),
 541 #endif
 542 #if LCD_DEPTH == 16
 543     R(lcd_bitmap_transparent_part),
 544     R(lcd_bitmap_transparent),
 545 #endif
 546 #endif
 547 #ifdef HAVE_LCD_COLOR
 548     R(lcd_rgbpack),
 549     R(lcd_rgbunpack),
 550 #endif
 551
 552     /* Kernel */
 553     R(current_tick),
 554
 555     /* Buttons */
 556 #ifdef HAVE_TOUCHSCREEN
 557     R(action_get_touchscreen_press),
 558     R(touchscreen_set_mode),
 559 #endif
 560     R(kbd_input),
 561
 562     R(font_getstringsize),
 563     R(read_bmp_file),
 564     R(set_viewport),
 565     R(clear_viewport),
 566     R(current_path),
 567     R(gui_syncyesno_run),
 568
 569     {"new_image", rli_new},
 570
 571     {NULL, NULL}
 572 };
 573 #undef  R
 574 extern const luaL_Reg rocklib_aux[];
 575
 576
 577 #define RB_CONSTANT(x) lua_pushinteger(L, x); lua_setfield(L, -2, #x);
 578 /*
 579  ** Open Rockbox library
 580  */
 581 LUALIB_API int luaopen_rock(lua_State *L)
 582 {
 583     luaL_register(L, LUA_ROCKLIBNAME, rocklib);
 584     luaL_register(L, LUA_ROCKLIBNAME, rocklib_aux);
 585
 586     RB_CONSTANT(HZ);
 587
 588     RB_CONSTANT(LCD_WIDTH);
 589     RB_CONSTANT(LCD_HEIGHT);
 590
 591     RB_CONSTANT(FONT_SYSFIXED);
 592     RB_CONSTANT(FONT_UI);
 593
 594 #ifdef HAVE_TOUCHSCREEN
 595     RB_CONSTANT(TOUCHSCREEN_POINT);
 596     RB_CONSTANT(TOUCHSCREEN_BUTTON);
 597 #endif
 598
 599     rli_init(L);
 600
 601     return 1;
 602 }