Revert "Rocklua -- Extend / Fix rliImage"

This reverts commit 2daec3d3c3d84e7176a22bc073ca5530e8e44c6d.

Change-Id: I53ea1f491e3c6d6fb759f426f203f927bd26b1e9

1 files changed, 88 insertions, 1165 deletions

diff --git a/apps/plugins/lua/rocklib.c b/apps/plugins/lua/rocklib.c
index ced83a51df..2268063d3f 100644
--- a/apps/plugins/lua/rocklib.c
+++ b/apps/plugins/lua/rocklib.c
@@ -9,7 +9,6 @@
  *
  * Copyright (C) 2008 Dan Everton (safetydan)
  * Copyright (C) 2009 Maurus Cuelenaere
- * Copyright (C) 2017 William Wilgus
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -48,1215 +47,127 @@
 
 
 /*
- * -----------------------------------------------------------------------------
+ * -----------------------------
  *
  *  Rockbox Lua image wrapper
  *
- *  Some devices(1-bit / 2-bit displays) have packed bit formats that
- *  need to be unpacked in order to work on them at a pixel level.
- *
- *  The internal formats of these devices do not follow the same paradigm
- *  for image sizes either; We still display the actual width and height to
- *  the user but store stride based on the native values
- *
- *  Conversion between native addressing and per pixel addressing
- *  incurs extra overhead but it is much faster to do it
- *  on the 'C' side rather than in lua.
- *
- * -----------------------------------------------------------------------------
+ * -----------------------------
  */
 
-#ifdef HAVE_LCD_BITMAP
-#define RLI_EXTENDED
-#endif
-
 #define ROCKLUA_IMAGE "rb.image"
-#define ERR_IDX_RANGE "index out of range"
-#define ERR_DATA_OVF  "data overflow"
-
-/* mark for RLI to LUA Interface functions (luaState *L) is the only argument */
-#define RLI_LUA static int
-
-#ifndef ABS
-#define ABS(a)(((a) < 0) ? - (a) :(a))
-#endif
-
-#ifndef LCD_BLACK
-#define LCD_BLACK 0x0
-#endif
-
 struct rocklua_image
 {
-    int     width;
-    int     height;
-    int     stride;
-    size_t  elems;
+    int width;
+    int height;
     fb_data *data;
-    fb_data dummy[1];
+    fb_data dummy[1][1];
 };
 
-/* holds iterator data for rlimages */
-struct rli_iter_d
+static void rli_wrap(lua_State *L, fb_data *src, int width, int height)
 {
-    struct rocklua_image *img;
-    fb_data *elem;
-    int x , y;
-    int x1, y1;
-    int x2, y2;
-    int dx, dy;
-};
-
-/* __tostring information enums */
-enum rli_info {RLI_INFO_ALL = 0, RLI_INFO_TYPE, RLI_INFO_WIDTH,
-               RLI_INFO_HEIGHT, RLI_INFO_ELEMS, RLI_INFO_BYTES,
-               RLI_INFO_DEPTH, RLI_INFO_FORMAT, RLI_INFO_ADDRESS};
+    struct rocklua_image *a = (struct rocklua_image *)lua_newuserdata(L, sizeof(struct rocklua_image));
 
-#ifdef HAVE_LCD_COLOR
-
-static inline unsigned invert_color(unsigned rgb)
-{
-    uint8_t r = 0xFFU - RGB_UNPACK_RED((unsigned) rgb);
-    uint8_t g = 0xFFU - RGB_UNPACK_GREEN((unsigned) rgb);
-    uint8_t b = 0xFFU - RGB_UNPACK_BLUE((unsigned) rgb);
+    luaL_getmetatable(L, ROCKLUA_IMAGE);
+    lua_setmetatable(L, -2);
 
-    return LCD_RGBPACK(r, g, b);
+    a->width = width;
+    a->height = height;
+    a->data = src;
 }
-#else /* !HAVE_LCD_COLOR */
-
-#define invert_color(c) (~c)
-
-#endif /* HAVE_LCD_COLOR */
-
-
-#if (LCD_DEPTH > 2) /* no native to pixel mapping needed */
-
-#define pixel_to_fb(x, y, o, n) {(void) x; (void) y; do { } while (0);}
-#define pixel_to_native(x, y, xn, yn) {*xn = x; *yn = y;}
-#define init_pixelmask(x, y, m, p) do { } while (0)
-
-
-#else /* some devices need x | y coords shifted to match native format */
-
-static fb_data x_shift = 0;
-static fb_data y_shift = 0;
-static fb_data xy_mask = 0;
-static const fb_data *pixelmask = NULL;
-
-/* conversion between packed native formats and individual pixel addressing */
-static inline void init_pixelmask(fb_data *x_shift, fb_data *y_shift,
-                                  fb_data *xy_mask, const fb_data **pixelmask)
-{
-
-#if(LCD_PIXELFORMAT == VERTICAL_PACKING) && LCD_DEPTH == 1
-    static const fb_data pixelmask_v1[8] =
-               {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
-    *pixelmask = pixelmask_v1;
-
-    (void) x_shift;
-    *y_shift = 3U;
-    *xy_mask = ((1 << (*y_shift)) - 1);
-#elif(LCD_PIXELFORMAT == VERTICAL_PACKING) && LCD_DEPTH == 2
-    static const fb_data pixelmask_v2[4] = {0x03, 0x0C, 0x30, 0xC0};
-    *pixelmask = pixelmask_v2;
-
-    (void) x_shift;
-    *y_shift = 2U;
-    *xy_mask = ((1 << (*y_shift)) - 1);
-#elif(LCD_PIXELFORMAT == VERTICAL_INTERLEAVED) && LCD_DEPTH == 2
-    static const fb_data pixelmask_vi2[8] =
-               {0x0101, 0x0202, 0x0404, 0x0808, 0x1010, 0x2020, 0x4040, 0x8080};
-    *pixelmask = pixelmask_vi2;
-
-    (void) x_shift;
-    *y_shift = 3U;
-    *xy_mask = ((1 << (*y_shift)) - 1);
-#elif(LCD_PIXELFORMAT == HORIZONTAL_PACKING) && LCD_DEPTH == 2
-    /* MSB on left */
-    static const fb_data pixelmask_h2[4] = {0x03, 0x0C, 0x30, 0xC0};
-    *pixelmask = pixelmask_h2;
-
-    (void) y_shift;
-    *x_shift = 2U;
-    *xy_mask = ((1 << (*x_shift)) - 1);
-#else
-    #warning Unknown Pixel Format
-#endif /* LCD_PIXELFORMAT */
-
-} /* init_pixelmask */
-
-static inline void pixel_to_native(int x, int y, int *x_native, int *y_native)
-{
-    *x_native = ((x - 1) >> x_shift) + 1;
-    *y_native = ((y - 1) >> y_shift) + 1;
-} /* pixel_to_native */
-
-static inline fb_data set_masked_pixel(fb_data old,
-                                       fb_data new,
-                                       fb_data mask,
-                                       int bit_n)
-{
-    /*equivalent of: (old & (~mask)) | ((new << bit_n) & mask);*/
-    return old ^ ((old ^ (new << bit_n)) & mask);
-
-} /* set_masked_pixel */
-
-static inline fb_data get_masked_pixel(fb_data val, fb_data mask, int bit_n)
-{
-    val = val & mask;
-    return val >> bit_n;
-} /* get_masked_pixel */
-
-/* conversion between packed native formats and individual pixel addressing */
-static void pixel_to_fb(int x, int y, fb_data *oldv, fb_data *newv)
-{
-    fb_data mask;
-    int bit_n;
-
-#if(LCD_PIXELFORMAT == VERTICAL_INTERLEAVED) && LCD_DEPTH == 2
-    (void) x;
-    const uint16_t greymap_vi2[4] = {0x0000, 0x0001, 0x0100, 0x0101};
-
-    bit_n = (y - 1) & xy_mask;
-    mask  = pixelmask[bit_n];
-
-    *newv = greymap_vi2[*newv &(0x3)]; /* [0-3] => greymap */
-    *newv = set_masked_pixel(*oldv, *newv, mask, bit_n);
-
-    *oldv = get_masked_pixel(*oldv, mask, bit_n);
-
-    if((*oldv) > 1) /* greymap => [0-3] */
-        *oldv = ((*oldv) & 0x1U) + 2U; /* 2, 3 */
-    else
-        *oldv &= 1U; /* 0, 1 */
-
-#elif(LCD_DEPTH <= 2)
-    if(y_shift)
-        bit_n = (y - 1) & xy_mask;
-    else if(x_shift)
-        bit_n = xy_mask - ((x - 1) & xy_mask); /*MSB on left*/
-
-    if(y_shift || x_shift)
-    {
-        mask   = pixelmask[bit_n];
-        bit_n *= LCD_DEPTH;
-
-        *newv = set_masked_pixel(*oldv, *newv, mask, bit_n);
 
-        *oldv = get_masked_pixel(*oldv, mask, bit_n);
-    }
-#else
-    #error Unknown Pixel Format
-#endif /* LCD_PIXELFORMAT == VERTICAL_INTERLEAVED && LCD_DEPTH == 2 */
-} /* pixel_to_fb */
-
-#endif /* (LCD_DEPTH > 2) no native to pixel mapping needed */
-
-/* Internal worker functions for image data array *****************************/
-
-static inline void swap_int(bool swap, int *v1, int *v2)
+static fb_data* rli_alloc(lua_State *L, int width, int height)
 {
-    if(swap)
-    {
-        int val = *v1;
-        *v1 = *v2;
-        *v2 = val;
-    }
-} /* swap_int */
-
-/* Throws error if x or y are out of bounds notifies user which narg indice
-   the out of bound variable originated */
-static void bounds_check_xy(lua_State *L, struct rocklua_image *img,
-                         int nargx, int x, int nargy, int y)
-{
-    luaL_argcheck(L, x <= img->width && x > 0,  nargx, ERR_IDX_RANGE);
-    luaL_argcheck(L, y <= img->height && y > 0, nargy, ERR_IDX_RANGE);
-} /* bounds_check_xy */
-
-static struct rocklua_image* rli_checktype(lua_State *L, int arg)
-{
-    void *ud = luaL_checkudata(L, arg, ROCKLUA_IMAGE);
-
-    luaL_argcheck(L, ud != NULL, arg, "'" ROCKLUA_IMAGE "' expected");
-
-    return (struct rocklua_image*) ud;
-} /* rli_checktype */
-
-static struct rocklua_image * alloc_rlimage(lua_State *L, bool alloc_data,
-                                            int width, int height)
-{
-    /* rliimage is pushed on the stack it is up to you to pop it */
-    struct rocklua_image *img;
-
-    const size_t sz_header = sizeof(struct rocklua_image);
-    size_t sz_data = 0;
-    size_t n_elems;
-
-    int w_native;
-    int h_native;
-
-    pixel_to_native(width, height, &w_native, &h_native);
-
-    n_elems = (size_t)(w_native * h_native);
-
-    if(alloc_data) /* if this a new image we need space for image data */
-        sz_data = n_elems * sizeof(fb_data);
-
-    /* newuserdata pushes the userdata onto the stack */
-    img = (struct rocklua_image *) lua_newuserdata(L, sz_header + sz_data);
+    size_t nbytes = sizeof(struct rocklua_image) + ((width*height) - 1) * sizeof(fb_data);
+    struct rocklua_image *a = (struct rocklua_image *)lua_newuserdata(L, nbytes);
 
     luaL_getmetatable(L, ROCKLUA_IMAGE);
     lua_setmetatable(L, -2);
 
-    /* apparent w/h is stored but behind the scenes native w/h is used */
-    img->width  = width;
-    img->height = height;
-    img->stride = w_native;
-    img->elems  = n_elems;
-
-    return img;
-} /* alloc_rlimage */
-
-static inline void rli_wrap(lua_State *L, fb_data *src, int width, int height)
-{
-    /* rliimage is pushed on the stack it is up to you to pop it */
-    struct rocklua_image *a = alloc_rlimage(L, false, width, height);
-
-    a->data = src;
-} /* rli_wrap */
-
-static inline fb_data* rli_alloc(lua_State *L, int width, int height)
-{
-    /* rliimage is pushed on the stack it is up to you to pop it */
-    struct rocklua_image *a = alloc_rlimage(L, true, width, height);
-
-    a->data = &a->dummy[0]; /* ref to beginning of alloc'd img data */
+    a->width = width;
+    a->height = height;
+    a->data = &a->dummy[0][0];
 
     return a->data;
-} /* rli_alloc */
-
-static inline fb_data data_setget(fb_data *elem, int x, int y, fb_data *val)
-{
-    fb_data old_val = 0;
-    fb_data new_val = 0;
-
-    if(elem)
-    {
-        old_val = *elem;
-
-        if(val)
-        {
-            new_val = *val;
-            pixel_to_fb(x, y, &old_val, &new_val);
-            *elem = new_val;
-        }
-        else
-            pixel_to_fb(x, y, &old_val, &new_val);
-    }
-
-    return old_val;
-} /* data_setget */
-
-static inline fb_data data_set(fb_data *elem, int x, int y, fb_data *new_val)
-{
-    /* get and set share the same underlying function */
-    return data_setget(elem, x, y, new_val);
-} /* data_set */
-
-static inline fb_data data_get(fb_data *elem, int x, int y)
-{
-    /* get and set share the same underlying function */
-    return data_setget(elem, x, y, NULL);
-} /* data_get */
-
-static fb_data* rli_get_element(struct rocklua_image* img, int x, int y)
-{
-    int stride      = img->stride;
-    size_t elements = img->elems;
-    fb_data *data   = img->data;
-
-    pixel_to_native(x, y, &x, &y);
-
-    /* row major address */
-    size_t data_address = (stride * (y - 1)) + (x - 1);
-
-    /* x needs bound between 0 and stride otherwise overflow to prev/next y */
-    if(x <= 0 || x > stride || data_address >= elements)
-        return NULL; /* data overflow */
-
-    return &data[data_address]; /* return element address */
-} /* rli_get_element */
-
-/* Lua to C Interface for pixel set and get functions */
-static int rli_setget(lua_State *L, bool is_get)
-{
-    /*(set) (dst*, [x1, y1, clr, clip]) */
-    /*(get) (dst*, [x1, y1, clip]) */
-    struct rocklua_image *a = rli_checktype(L, 1);
-    int x = luaL_checkint(L, 2);
-    int y = luaL_checkint(L, 3);
-
-    fb_data clr = 0; /* Arg 4 is color if set element */
-    fb_data *p_clr = &clr;
-
-    int clip_narg;
-
-    if(is_get) /* get element */
-    {
-        p_clr = NULL;
-        clip_narg = 4;
-    }
-    else /* set element */
-    {
-        clr = FB_SCALARPACK((unsigned) luaL_checknumber(L, 4));
-        clip_narg = 5;
-    }
-
-    fb_data *element = rli_get_element(a, x, y);
-
-    if(!element)
-    {
-        if(!luaL_optboolean(L, clip_narg, false)) /* Error if !clip */
-            bounds_check_xy(L, a, 2, x, 3, y);
-
-        lua_pushnil(L);
-        return 1;
-    }
-
-    lua_pushnumber(L, FB_UNPACK_SCALAR_LCD(data_setget(element, x, y, p_clr)));
-
-    /* returns old value */
-    return 1;
-} /* rli_setget */
-
-#ifdef RLI_EXTENDED
-static bool init_rli_iter(struct rli_iter_d *d,
-                          struct rocklua_image *img,
-                          int x1, int y1,
-                          int x2, int y2,
-                          int dx, int dy,
-                          bool swx, bool swy)
-{
-
-    swap_int((swx), &x1, &x2);
-    swap_int((swy), &y1, &y2);
-
-    /* stepping in the correct x direction ? */
-    if((dx > 0 && x1 > x2) || (dx < 0 && x1 < x2))
-        dx = -dx;
-
-    /* stepping in the correct y direction ? */
-    if((dy > 0 && y1 > y2) || (dy < 0 && y1 < y2))
-        dy = -dy;
-
-    d->img = img;
-    d->x   = x1;
-    d->y   = y1;
-    d->x1  = x1;
-    d->y1  = y1;
-    d->x2  = x2;
-    d->y2  = y2;
-    d->dx  = dx;
-    d->dy  = dy;
-    d->elem = rli_get_element(img, d->x, d->y);
-
-    return(dx != 0 || dy != 0);
-} /* init_rli_iter */
-
-/* steps to the next point(x, y) by delta x/y, stores pointer to element
-   returns true if x & y haven't reached x2 & y2
-   if limit reached - element set to NULL, deltas set to 0 & false returned
-*/
-static bool next_rli_iter(struct rli_iter_d *d)
-{
-    if((d->dx > 0 && d->x < d->x2) || (d->dx < 0 && d->x > d->x2))
-        d->x += d->dx;
-    else if((d->dy > 0 && d->y < d->y2) || (d->dy < 0 && d->y > d->y2))
-    {
-        d->x = d->x1; /* Reset x*/
-        d->y += d->dy;
-    }
-    else
-    {
-        d->elem = NULL;
-        d->dx = 0;
-        d->dy = 0;
-        return false;
-    }
-
-    d->elem = rli_get_element(d->img, d->x, d->y);
-
-    return true;
-} /* next_rli_iter */
-
-static int d_line(struct rocklua_image *img,
-                  int x1, int y1,
-                  int x2, int y2,
-                  fb_data *clr,
-                  bool clip)
-{
-    /* NOTE! clr passed as pointer */
-    /* Bresenham midpoint line algorithm */
-    fb_data *element;
-
-    int r_a = x2 - x1; /* range of x direction called 'a' for now */
-    int r_b = y2 - y1; /* range of y direction called 'b' for now */
-
-    int s_a = 1; /* step of a direction */
-    int s_b = 1; /* step of b direction */
-
-    int d_err;
-    int numpixels;
-
-    int *a1 = &x1; /* pointer to the x var 'a' */
-    int *b1 = &y1; /* pointer to the y var 'b' */
-
-    if(r_a < 0) /* instead of negative range we will switch step instead */
-    {
-        r_a = -r_a;
-        s_a = -s_a;
-    }
-
-    if(r_b < 0) /* instead of negative range we will switch step instead */
-    {
-        r_b = -r_b;
-        s_b = -s_b;
-    }
-
-    x2 += s_a; /* add 1 extra point to make the whole line */
-    y2 += s_b; /* add 1 extra point */
-
-    if(r_b > r_a) /*if rangeY('b') > rangeX('a') swap their identities */
-    {
-        a1 = &y1;
-        b1 = &x1;
-        swap_int((true), &r_a, &r_b);
-        swap_int((true), &s_a, &s_b);
-    }
-
-    d_err = ((r_b << 1) - r_a) >> 1; /* preload err of 1 step (px centered) */
-
-    numpixels = r_a + 1;
-
-    r_a -= r_b; /* pre-subtract 'a' - 'b' */
-
-    for(;numpixels > 0; numpixels--)
-    {
-        element = rli_get_element(img, x1, y1);
-        if(element || clip)
-            data_set(element, x1, y1, clr);
-        else
-            return numpixels + 1; /* Error */
-
-        if(d_err >= 0) /* 0 is our target midpoint(exact point on the line) */
-        {
-            *b1 += s_b; /* whichever axis is in 'b' stepped(-1 or +1) */
-            d_err -= r_a;
-        }
-        else
-            d_err += r_b; /* only add 'b' when d_err < 0 */
-
-        *a1 += s_a; /* whichever axis is in 'a' stepped(-1 or +1) */
-    }
-
-    return 0;
-} /* d_line */
-
-/* ellipse worker function */
-static int d_ellipse_elements(struct rocklua_image * img,
-                              int x1, int y1,
-                              int x2, int y2,
-                              int sx, int sy,
-                              fb_data *clr,
-                              fb_data *fillclr,
-                              bool clip)
-{
-    int ret = 0;
-    fb_data *element1, *element2, *element3, *element4;
-
-    if(fillclr && x1 - sx != x2 + sx)
-    {
-        ret |= d_line(img, x1, y1, x2, y1, fillclr, clip); /* I. II.*/
-        ret |= d_line(img, x1, y2, x2, y2, fillclr, clip); /* III.IV.*/
-    }
-
-    x1 -= sx; /* shift x & y */
-    y1 -= sy;
-    x2 += sx;
-    y2 += sy;
-
-    element1 = rli_get_element(img, x2, y1);
-    element2 = rli_get_element(img, x1, y1);
-    element3 = rli_get_element(img, x1, y2);
-    element4 = rli_get_element(img, x2, y2);
-
-    if(clip || (element1 && element2 && element3 && element4))
-    {
-        data_set(element1, x2, y1, clr); /*   I. Quadrant +x +y */
-        data_set(element2, x1, y1, clr); /*  II. Quadrant -x +y */
-        data_set(element3, x1, y2, clr); /* III. Quadrant -x -y */
-        data_set(element4, x2, y2, clr); /*  IV. Quadrant +x -y */
-    }
-    else
-        ret = 2; /* ERROR */
-
-    return ret;
-} /* d_ellipse_elements */
-
-static int d_ellipse(struct rocklua_image *img,
-                          int x1, int y1,
-                          int x2, int y2,
-                          fb_data *clr,
-                          fb_data *fillclr,
-                          bool clip)
-{
-    /* NOTE! clr and fillclr passed as pointers */
-    /* Rasterizing algorithm derivative of work by Alois Zing */
-#if LCD_WIDTH > 1024 || LCD_HEIGHT > 1024
-    /* Prevents overflow on large screens */
-    double dx, dy, err, e2;
-#else
-    long dx, dy, err, e2;
-#endif
-
-    int ret = 0;
-
-    int a = ABS(x2 - x1); /* diameter */
-    int b = ABS(y2 - y1); /* diameter */
-
-    if(a == 0 || b == 0 || !clr)
-        return ret; /* not an error but nothing to display */
-
-    int b1 = (b & 1);
-    b = b - (1 - b1);
-
-    int a2 = (a * a);
-    int b2 = (b * b);
-
-    dx = ((1 - a) * b2) >> 1; /* error increment */
-    dy = (b1 * a2) >> 1;      /* error increment */
-
-    err = dx + dy + b1 * a2; /* error of 1.step */
-
-    /* if called with swapped points .. exchange them */
-    swap_int((x1 > x2), &x1, &x2);
-    swap_int((y1 > y2), &y1, &y2);
-
-    y1 += (b + 1) >> 1;
-    y2 = y1 - b1;
-
-    do
-    {
-        ret = d_ellipse_elements(img, x1, y1, x2, y2, 0, 0, clr, fillclr, clip);
-
-        e2 = err;
-
-        /* using division because you can't use bit shift on doubles.. */
-        if(e2 <= (dy / 2)) /* target midpoint - y step */
-        {
-            y1++;
-            y2--;
-            dy  += a2;
-            err += dy;
-        }
-
-        if(e2 >= (dx / 2) || err > (dy / 2)) /* target midpoint - x step */
-        {
-            x1++;
-            x2--;
-            dx  += b2;
-            err += dx;
-        }
-
-    } while(ret == 0 && x1 <= x2);
-
-    while (ret == 0 && y1 - y2 < b) /* early stop of flat ellipse a=1 finish tip */
-    {
-        ret = d_ellipse_elements(img, x1, y1, x2, y2, 1, 0, clr, fillclr, clip);
-
-        y1++;
-        y2--;
-    }
-
-    return ret;
-} /* d_ellipse */
-
-/* Lua to C Interface for line and ellipse */
-static int rli_line_ellipse(lua_State *L, bool is_ellipse)
-{
-    struct rocklua_image *a = rli_checktype(L, 1);
-
-    int x1 = luaL_checkint(L, 2);
-    int y1 = luaL_checkint(L, 3);
-    int x2 = luaL_optint(L, 4, x1);
-    int y2 = luaL_optint(L, 5, y1);
-
-    fb_data clr = FB_SCALARPACK((unsigned) luaL_checknumber(L, 6));
-
-    fb_data fillclr; /* fill color is index 7 if is_ellipse */
-    fb_data *p_fillclr = NULL;
-
-    bool clip;
-    int clip_narg;
-
-    if(is_ellipse)
-        clip_narg = 8;
-    else
-        clip_narg = 7;
-
-    clip = luaL_optboolean(L, clip_narg, false);
-
-    if(!clip)
-    {
-        bounds_check_xy(L, a, 2, x1, 3, y1);
-        bounds_check_xy(L, a, 4, x2, 5, y2);
-    }
-
-    if(is_ellipse)
-    {
-        if(!lua_isnoneornil(L, 7))
-        {
-            fillclr = FB_SCALARPACK((unsigned) luaL_checkint(L, 7));
-            p_fillclr = &fillclr;
-        }
-
-        luaL_argcheck(L, d_ellipse(a, x1, y1, x2, y2, &clr, p_fillclr, clip) == 0,
-                      1, ERR_DATA_OVF);
-    }
-    else
-        luaL_argcheck(L, d_line(a, x1, y1, x2, y2, &clr, clip) == 0,
-                      1, ERR_DATA_OVF);
-
-    return 0;
-} /* rli_line_ellipse */
-
-/* Pushes lua function from Stack at position narg to top of stack
-   and puts a reference in the global registry for later use       */
-static inline int register_luafunc(lua_State *L, int narg_funct)
-{
-        lua_pushvalue(L, narg_funct); /* lua function */
-        int lf_ref = luaL_ref(L, LUA_REGISTRYINDEX);
-        lua_settop(L, 0); /* clear C stack for use by lua function */
-        return lf_ref;
-} /* register_luafunc */
-
-/* User defined pixel manipulations through rli_copy, rli_marshal */
-static int custom_transform(lua_State *L,
-                            struct rli_iter_d *ds,
-                            struct rli_iter_d *ss,
-                            int op,
-                            fb_data *color)
-{
-    (void) color;
-
-    fb_data dst;
-    fb_data src;
-
-    unsigned int params = 3;
-    int ret = 0;
-
-    lua_rawgeti(L, LUA_REGISTRYINDEX, op);
-
-    dst = data_get(ds->elem, ds->x, ds->y);
-    lua_pushnumber(L, FB_UNPACK_SCALAR_LCD(dst));
-    lua_pushnumber(L, ds->x);
-    lua_pushnumber(L, ds->y);
-
-    if(ss) /* Allows src to be omitted */
-    {
-        params  += 3;
-        src = data_get(ss->elem, ss->x, ss->y);
-        lua_pushnumber(L, FB_UNPACK_SCALAR_LCD(src));
-        lua_pushnumber(L, ss->x);
-        lua_pushnumber(L, ss->y);
-    }
-
-    lua_call(L, params, 2); /* call custom function w/ n-params & 2 ret */
-
-    if(!lua_isnoneornil(L, -2))
-    {
-        ret = 1;
-        dst = FB_SCALARPACK((unsigned) luaL_checknumber(L, -2));
-        data_set(ds->elem, ds->x, ds->y, &dst);
-    }
-
-    if(!lua_isnoneornil(L, -1) && ss)
-    {
-        ret |= 2;
-        src = FB_SCALARPACK((unsigned) luaL_checknumber(L, -1));
-        data_set(ss->elem, ss->x, ss->y, &src);
-    }
-
-    lua_pop(L, 2);
-    return ret; /* 0 signals iterator to stop */
-} /* custom_transform */
-
-/* Pre defined pixel manipulations through rli_copy */
-static int blit_transform(lua_State *L,
-                          struct rli_iter_d *ds,
-                          struct rli_iter_d *ss,
-                          int op,
-                          fb_data *color)
-{
-    (void) L;
-    fb_data clr = *color;
-    fb_data dst = data_get(ds->elem, ds->x, ds->y);
-    fb_data src;
-
-    /* Reuse 0 - 7 for src / clr blits*/
-    if(op >= 30 && op <= 37)
-    {
-        op -= 30;
-        src = clr;
-    }
-    else
-        src = data_get(ss->elem, ss->x, ss->y);
-
-    switch(op)
-    {
-        default:
-        /* case 30: */
-        case 0:  { dst = src;          break; }/* copyS/C  */
-        /* case 31: */
-        case 1:  { dst = src | dst;    break; }/* DorS/C   */
-        /* case 32: */
-        case 2:  { dst = src ^ dst;    break; }/* DxorS/C  */
-        /* case 33: */
-        case 3:  { dst = ~(src | dst); break; }/* nDorS/C  */
-        /* case 34: */
-        case 4:  { dst = (~src) | dst; break; }/* DornS/C  */
-        /* case 35: */
-        case 5:  { dst = src & dst;    break; }/* DandS/C  */
-        /* case 36: */
-        case 6:  { dst = src & (~dst); break; }/* nDandS/C */
-        /* case 37: */
-        case 7:  { dst = ~src;         break; }/* notS/C   */
-
-        /* mask blits */
-        case 8:  { if(src != 0) { dst = clr; } break; }/* Sand */
-        case 9:  { if(src == 0) { dst = clr; } break; }/* Snot */
-
-        case 10:  { dst  = src | clr;           break; }/* SorC  */
-        case 11:  { dst  = src ^ clr;           break; }/* SxorC */
-        case 12:  { dst  = ~(src | clr);        break; }/* nSorC */
-        case 13:  { dst  = src | (~clr);        break; }/* SornC */
-        case 14:  { dst  = src & clr;           break; }/* SandC */
-        case 15:  { dst  = (~src) & clr;        break; }/* nSandC */
-        case 16:  { dst |= (~src) | clr;        break; }/* DornSorC */
-        case 17:  { dst ^= (src & (dst ^ clr)); break; }/* DxorSandDxorC */
-
-        case 18: { if(src != clr) { dst = src; } break; }
-        case 19: { if(src == clr) { dst = src; } break; }
-        case 20: { if(src > clr)  { dst = src; } break; }
-        case 21: { if(src < clr)  { dst = src; } break; }
-
-        case 22: { if(dst != clr) { dst = src; } break; }
-        case 23: { if(dst == clr) { dst = src; } break; }
-        case 24: { if(dst > clr)  { dst = src; } break; }
-        case 25: { if(dst < clr)  { dst = src; } break; }
-
-        case 26: { if(dst != src) { dst = clr; } break; }
-        case 27: { if(dst == src) { dst = clr; } break; }
-        case 28: { if(dst > src)  { dst = clr; } break; }
-        case 29: { if(dst < src)  { dst = clr; } break; }
-
-    }/*switch op*/
-
-    data_set(ds->elem, ds->x, ds->y, &dst);
-    return 1;
-} /* blit_transform */
+}
 
-static int invert_transform(lua_State *L,
-                            struct rli_iter_d *ds,
-                            struct rli_iter_d *ss,
-                            int op,
-                            fb_data *color)
+static int rli_new(lua_State *L)
 {
-    (void) L;
-    (void) color;
-    (void) op;
-    (void) ss;
-
-    fb_data val = invert_color(data_get(ds->elem, ds->x, ds->y));
-    data_set(ds->elem, ds->x, ds->y, &val);
-
-    return 1;
-} /* invert_transform */
-#endif /* RLI_EXTENDED */
-
-/* RLI to LUA Interface functions *********************************************/
-RLI_LUA rli_new(lua_State *L)
-{   /* [width, height] */
-    int width  = luaL_optint(L, 1, LCD_WIDTH);
-    int height = luaL_optint(L, 2, LCD_HEIGHT);
-
-    luaL_argcheck(L, width  > 0, 1, ERR_IDX_RANGE);
-    luaL_argcheck(L, height > 0, 2, ERR_IDX_RANGE);
+    int width = luaL_checkint(L, 1);
+    int height = luaL_checkint(L, 2);
 
     rli_alloc(L, width, height);
 
     return 1;
 }
 
-RLI_LUA rli_set(lua_State *L)
-{
-    /*(set) (dst*, [x1, y1, clr, clip]) */
-    /* get and set share the same underlying function */
-    return rli_setget(L, false);
-}
-
-RLI_LUA rli_get(lua_State *L)
-{
-    /*(get) (dst*, [x1, y1, clip]) */
-    /* get and set share the same underlying function */
-    return rli_setget(L, true);
-}
-
-RLI_LUA rli_height(lua_State *L)
+static struct rocklua_image* rli_checktype(lua_State *L, int arg)
 {
-    struct rocklua_image *a = rli_checktype(L, 1);
-    lua_pushnumber(L, a->height);
-    return 1;
+    void *ud = luaL_checkudata(L, arg, ROCKLUA_IMAGE);
+    luaL_argcheck(L, ud != NULL, arg, "'" ROCKLUA_IMAGE "' expected");
+    return (struct rocklua_image*) ud;
 }
 
-RLI_LUA rli_width(lua_State *L)
+static int rli_width(lua_State *L)
 {
     struct rocklua_image *a = rli_checktype(L, 1);
     lua_pushnumber(L, a->width);
     return 1;
 }
 
-RLI_LUA rli_equal(lua_State *L)
-{
-    struct rocklua_image *a = rli_checktype(L, 1);
-    struct rocklua_image *b = rli_checktype(L, 2);
-    lua_pushboolean(L, a->data == b->data);
-    return 1;
-}
-
-RLI_LUA rli_size(lua_State *L)
-{
-    struct rocklua_image *a = rli_checktype(L, 1);
-    lua_pushnumber(L, a->elems);
-    return 1;
-}
-
-RLI_LUA rli_raw(lua_State *L)
+static int rli_height(lua_State *L)
 {
-    /*val = (img*, index, [new_val]) */
     struct rocklua_image *a = rli_checktype(L, 1);
-
-    size_t i = (unsigned) luaL_checkint(L, 2);
-
-    fb_data val;
-
-    luaL_argcheck(L, i > 0 && i <= (a->elems), 2, ERR_IDX_RANGE);
-
-    lua_pushnumber(L, FB_UNPACK_SCALAR_LCD(a->data[i-1]));
-
-    if(!lua_isnoneornil(L, 3))
-    {
-        val = FB_SCALARPACK((unsigned) luaL_checknumber(L, 3));
-        a->data[i-1] = val;
-    }
-
+    lua_pushnumber(L, a->height);
     return 1;
 }
 
-RLI_LUA rli_tostring(lua_State *L)
+static fb_data* rli_element(lua_State *L)
 {
-    /* (img, [infoitem]) */
     struct rocklua_image *a = rli_checktype(L, 1);
+    int x = luaL_checkint(L, 2);
+    int y = luaL_checkint(L, 3);
 
-    int item     = (unsigned) luaL_optint(L, 2, 0);
-    size_t bytes = a->elems * sizeof(fb_data);
-
-    switch(item)
-    {
-        default:
-        case RLI_INFO_ALL:
-        {
-            lua_pushfstring(L,
-            ROCKLUA_IMAGE ": %dx%d, %d elements, %d bytes, %d-bit depth, %d pack",
-            a->width, a->height, a->elems, bytes, LCD_DEPTH, LCD_PIXELFORMAT);
-            break;
-        }
-        case RLI_INFO_TYPE:    { lua_pushfstring(L, ROCKLUA_IMAGE   ); break; }
-        case RLI_INFO_WIDTH:   { lua_pushfstring(L, "%d", a->width  ); break; }
-        case RLI_INFO_HEIGHT:  { lua_pushfstring(L, "%d", a->height ); break; }
-        case RLI_INFO_ELEMS:   { lua_pushfstring(L, "%d", a->elems  ); break; }
-        case RLI_INFO_BYTES:   { lua_pushfstring(L, "%d", bytes     ); break; }
-        case RLI_INFO_DEPTH:   { lua_pushfstring(L, "%d", LCD_DEPTH ); break; }
-        case RLI_INFO_FORMAT:  { lua_pushfstring(L, "%d", LCD_PIXELFORMAT); break; }
-        case RLI_INFO_ADDRESS: { lua_pushfstring(L, "%p", a->data); break; }
-    }
-
-    return 1;
-}
-
-#ifdef RLI_EXTENDED
-RLI_LUA rli_ellipse(lua_State *L)
-{
-    /* (dst*, x1, y1, x2, y2, [clr, fillclr, clip]) */
-    /* line and ellipse share the same init function */
-    return rli_line_ellipse(L, true);
-}
-
-RLI_LUA rli_line(lua_State *L)
-{
-    /* (dst*, x1, y1, [x2, y2, clr, clip]) */
-    /* line and ellipse share the same init function */
-    return rli_line_ellipse(L, false);
-}
-
-RLI_LUA rli_iterator(lua_State *L) {
-    /* see rli_iterator_factory */
-    struct rli_iter_d *ds;
-    ds = (struct rli_iter_d *) lua_touserdata(L, lua_upvalueindex(1));
-
-    if(ds->dx != 0 || ds->dy != 0)
-    {
-        lua_pushnumber(L, FB_UNPACK_SCALAR_LCD(data_get(ds->elem, ds->x, ds->y)));
-
-        lua_pushinteger(L, ds->x);
-        lua_pushinteger(L, ds->y);
-
-        next_rli_iter(ds); /* load next element */
-
-        return 3;
-    }
-    return 0; /* nothing left to do */
-}
-
-RLI_LUA rli_iterator_factory(lua_State *L) {
-    /* (src*, [x1, y1, x2, y2, dx, dy]) */
-    struct rocklua_image *a = rli_checktype(L, 1); /*image we wish to iterate*/
-
-    struct rli_iter_d *ds;
-
-    int x1  = luaL_optint(L, 2, 1);
-    int y1  = luaL_optint(L, 3, 1);
-    int x2  = luaL_optint(L, 4, a->width  - x1 + 1);
-    int y2  = luaL_optint(L, 5, a->height - y1 + 1);
-    int dx  = luaL_optint(L, 6, 1);
-    int dy  = luaL_optint(L, 7, 1);
-
-    /* create new iter + pushed onto stack */
-    ds = (struct rli_iter_d *) lua_newuserdata(L, sizeof(struct rli_iter_d));
-
-    init_rli_iter(ds, a, x1, y1, x2, y2, dx, dy, false, false);
-
-    /* returns the iter function with embedded iter data(up values) */
-    lua_pushcclosure(L, &rli_iterator, 1);
+    luaL_argcheck(L, 1 <= x && x <= a->width, 2,
+                    "index out of range");
+    luaL_argcheck(L, 1 <= y && y <= a->height, 3,
+                    "index out of range");
 
-    return 1;
+    /* return element address */
+    return &a->data[a->width * (y - 1) + (x - 1)];
 }
 
-RLI_LUA rli_marshal(lua_State *L) /* also invert */
+static int rli_set(lua_State *L)
 {
-    /* (img*, [x1, y1, x2, y2, dx, dy, clip, function]) */
-    struct rocklua_image *a = rli_checktype(L, 1);
-
-    struct rli_iter_d ds;
-
-    int x1 = luaL_optint(L, 2, 1);
-    int y1 = luaL_optint(L, 3, 1);
-    int x2 = luaL_optint(L, 4, a->width);
-    int y2 = luaL_optint(L, 5, a->height);
-    int dx = luaL_optint(L, 6, 1);
-    int dy = luaL_optint(L, 7, 1);
-    bool clip    = luaL_optboolean(L, 8, false);
-
-    int lf_ref = LUA_NOREF; /* de-ref'd without consequence */
-
-    int (*rli_trans)(lua_State *, struct rli_iter_d *, struct rli_iter_d *, int, fb_data *);
-    rli_trans = invert_transform; /* default transformation */
-
-    if(!clip)
-    {
-        bounds_check_xy(L, a, 2, x1, 3, y1);
-        bounds_check_xy(L, a, 4, x2, 5, y2);
-    }
-
-    init_rli_iter(&ds, a, x1, y1, x2, y2, dx, dy, false, false);
-
-    if(lua_isfunction(L, 9)) /* custom function */
-    {
-        rli_trans = custom_transform;
-        lf_ref = register_luafunc(L, 9);
-    }
-
-    do
-    {
-        luaL_argcheck(L, clip || (ds.elem != NULL), 1, ERR_DATA_OVF);
-
-        if(!(*rli_trans)(L, &ds, NULL, lf_ref, NULL))
-            break; /* Custom op can quit early */
-
-    } while(next_rli_iter(&ds));
-
-    luaL_unref(L, LUA_REGISTRYINDEX, lf_ref); /* de-reference custom function */
+    fb_data newvalue = FB_SCALARPACK((unsigned)luaL_checknumber(L, 4));
+    *rli_element(L) = newvalue;
     return 0;
 }
 
-RLI_LUA rli_copy(lua_State *L)
+static int rli_get(lua_State *L)
 {
-    /* (dst*, src*, [d_x, d_y, s_x, s_y, x_off, y_off, clip, [op, funct/clr]]) */
-    struct rocklua_image *d = rli_checktype(L, 1); /*dst*/
-    struct rocklua_image *s = rli_checktype(L, 2); /*src*/
-
-    struct rli_iter_d ds; /*dst*/
-    struct rli_iter_d ss; /*src*/
-
-    /* copy whole image if possible */
-    if(s->elems == d->elems && s->width == d->width && lua_gettop(L) < 3)
-    {
-        memcpy(d->data, s->data, d->elems * sizeof(fb_data));
-        return 0;
-    }
-
-    int d_x = luaL_optint(L, 3, 1);
-    int d_y = luaL_optint(L, 4, 1);
-    int s_x = luaL_optint(L, 5, 1);
-    int s_y = luaL_optint(L, 6, 1);
-
-    int w = MIN(d->width - d_x, s->width - s_x);
-    int h = MIN(d->height - d_y, s->height - s_y);
-
-    int x_off = luaL_optint(L, 7, w);
-    int y_off = luaL_optint(L, 8, h);
-
-    bool clip = luaL_optboolean(L, 9, false);
-    int op = luaL_optint(L, 10, 0);
-    fb_data clr = 0; /* 11 is custom function | color */
-
-    bool d_swx = (x_off < 0); /* dest swap */
-    bool d_swy = (y_off < 0);
-    bool s_swx = false; /* src  swap */
-    bool s_swy = false;
-
-    int (*rli_trans)(lua_State *, struct rli_iter_d *, struct rli_iter_d *, int, fb_data *);
-    rli_trans = blit_transform; /* default transformation */
-
-    int lf_ref = LUA_NOREF; /* de-ref'd without consequence */
-
-    if(!clip) /* Out of bounds is not allowed */
-    {
-        bounds_check_xy(L, d, 3, d_x, 4, d_y);
-        bounds_check_xy(L, s, 5, s_x, 6, s_y);
-    }
-    else if (w < 0 || h < 0) /* not an error but nothing to display */
-        return 0;
-
-    w = MIN(w, ABS(x_off));
-    h = MIN(h, ABS(y_off));
-
-    /* if(s->data == d->data) need to care about fill direction */
-    if(d_x > s_x)
-    {
-        d_swx = !d_swx;
-        s_swx = !s_swx;
-    }
-
-    if(d_y > s_y)
-    {
-        d_swy = !d_swy;
-        s_swy = !s_swy;
-    }
-
-    init_rli_iter(&ds, d, d_x, d_y, d_x + w, d_y + h, 1, 1, d_swx, d_swy);
-
-    init_rli_iter(&ss, s, s_x, s_y, s_x + w, s_y + h, 1, 1, s_swx, s_swy);
-
-    if (op == 0xFF && lua_isfunction(L, 11)) /* custom function specified.. */
-    {
-        rli_trans = custom_transform;
-        lf_ref = register_luafunc(L, 11);
-        op = lf_ref;
-    }
-    else
-        clr = FB_SCALARPACK((unsigned) luaL_optnumber(L, 11, LCD_BLACK));
-
-    do
-    {
-        if(!clip)
-        {
-            luaL_argcheck(L, ss.elem != NULL, 2, ERR_DATA_OVF);
-            luaL_argcheck(L, ds.elem != NULL, 1, ERR_DATA_OVF);
-        }
-
-        if(!(*rli_trans)(L, &ds, &ss, op, &clr))
-            break; /* Custom op can quit early */
-
-    } while(next_rli_iter(&ds) && next_rli_iter(&ss));
-
-    luaL_unref(L, LUA_REGISTRYINDEX, lf_ref); /* de-reference custom function */
-    return 0;
+    lua_pushnumber(L, FB_UNPACK_SCALAR_LCD(*rli_element(L)));
+    return 1;
 }
 
-RLI_LUA rli_clear(lua_State *L)
+static int rli_tostring(lua_State *L)
 {
-    /* (dst*, [color, x1, y1, x2, y2, clip]) */
     struct rocklua_image *a = rli_checktype(L, 1);
-
-    struct rli_iter_d ds;
-
-    fb_data clr = FB_SCALARPACK((unsigned) luaL_optnumber(L, 2, LCD_BLACK));
-    int x1 = luaL_optint(L, 3, 1);
-    int y1 = luaL_optint(L, 4, 1);
-    int x2 = luaL_optint(L, 5, a->width);
-    int y2 = luaL_optint(L, 6, a->height);
-    bool clip = luaL_optboolean(L, 7, false);
-
-    if(!clip)
-    {
-        bounds_check_xy(L, a, 3, x1, 4, y1);
-        bounds_check_xy(L, a, 5, x2, 6, y2);
-    }
-
-    init_rli_iter(&ds, a, x1, y1, x2, y2, 1, 1, false, false);
-
-    do
-    {
-        luaL_argcheck(L, clip || (ds.elem != NULL), 1, ERR_DATA_OVF);
-
-        data_set(ds.elem, ds.x, ds.y, &clr);
-
-    } while(next_rli_iter(&ds));
-
-    return 0;
+    lua_pushfstring(L, ROCKLUA_IMAGE ": %dx%d", a->width, a->height);
+    return 1;
 }
-#endif /* RLI_EXTENDED */
 
-/* Rli Image methods exported to lua */
 static const struct luaL_reg rli_lib [] =
 {
     {"__tostring", rli_tostring},
-    {"_data",      rli_raw},
-    {"__len",      rli_size},
-    {"__eq",       rli_equal},
-    {"width",      rli_width},
-    {"height",     rli_height},
-    {"set",        rli_set},
-    {"get",        rli_get},
-
-#ifdef RLI_EXTENDED
-    {"copy",       rli_copy},
-    {"clear",      rli_clear},
-    {"invert",     rli_marshal},
-    {"marshal",    rli_marshal},
-    {"points",     rli_iterator_factory},
-    {"line",       rli_line},
-    {"ellipse",    rli_ellipse},
-#endif /* RLI_EXTENDED */
+    {"set", rli_set},
+    {"get", rli_get},
+    {"width", rli_width},
+    {"height", rli_height},
     {NULL, NULL}
 };
 
 static inline void rli_init(lua_State *L)
 {
-    /* some devices need x | y coords shifted to match native format */
-    /* conversion between packed native formats and individual pixel addressing */
-    init_pixelmask(&x_shift, &y_shift, &xy_mask, &pixelmask);
-
     luaL_newmetatable(L, ROCKLUA_IMAGE);
 
     lua_pushstring(L, "__index");
@@ -1278,45 +189,57 @@ static inline void rli_init(lua_State *L)
 #define SIMPLE_VOID_WRAPPER(func) RB_WRAP(func) { (void)L; func(); return 0; }
 
 /* Helper function for opt_viewport */
-static void check_tablevalue(lua_State *L,
-                             const char* key,
-                             int tablepos,
-                             void* res,
-                             bool is_unsigned)
+static void check_tablevalue(lua_State *L, const char* key, int tablepos, void* res, bool unsigned_val)
 {
     lua_getfield(L, tablepos, key); /* Find table[key] */
 
-    int val = luaL_optint(L, -1, 0);
-
-    if(is_unsigned)
-        *(unsigned*)res = (unsigned) val;
-    else
-        *(int*)res = val;
+    if(!lua_isnoneornil(L, -1))
+    {
+        if(unsigned_val)
+            *(unsigned*)res = luaL_checkint(L, -1);
+        else
+            *(int*)res = luaL_checkint(L, -1);
+    }
 
     lua_pop(L, 1); /* Pop the value off the stack */
 }
 
-static inline struct viewport* opt_viewport(lua_State *L,
-                                     int narg,
-                                     struct viewport* vp,
-                                     struct viewport* alt)
+static struct viewport* opt_viewport(lua_State *L, int narg, struct viewport* alt)
 {
     if(lua_isnoneornil(L, narg))
         return alt;
 
+    int tablepos = lua_gettop(L);
+    struct viewport *vp;
+
+    lua_getfield(L, tablepos, "vp");  /* get table['vp'] */
+    if(lua_isnoneornil(L, -1))
+    {
+        lua_pop(L, 1); /* Pop nil off stack */
+
+        vp = (struct viewport*) lua_newuserdata(L, sizeof(struct viewport)); /* Allocate memory and push it as udata on the stack */
+        memset(vp, 0, sizeof(struct viewport)); /* Init viewport values to 0 */
+        lua_setfield(L, tablepos, "vp"); /* table['vp'] = vp (pops value off the stack) */
+    }
+    else
+    {
+        vp = (struct viewport*) lua_touserdata(L, -1); /* Reuse viewport struct */
+        lua_pop(L, 1); /* We don't need the value on stack */
+    }
+
     luaL_checktype(L, narg, LUA_TTABLE);
 
-    check_tablevalue(L, "x", narg, &vp->x, false);
-    check_tablevalue(L, "y", narg, &vp->y, false);
-    check_tablevalue(L, "width", narg, &vp->width, false);
-    check_tablevalue(L, "height", narg, &vp->height, false);
+    check_tablevalue(L, "x", tablepos, &vp->x, false);
+    check_tablevalue(L, "y", tablepos, &vp->y, false);
+    check_tablevalue(L, "width", tablepos, &vp->width, false);
+    check_tablevalue(L, "height", tablepos, &vp->height, false);
 #ifdef HAVE_LCD_BITMAP
-    check_tablevalue(L, "font", narg, &vp->font, false);
-    check_tablevalue(L, "drawmode", narg, &vp->drawmode, false);
+    check_tablevalue(L, "font", tablepos, &vp->font, false);
+    check_tablevalue(L, "drawmode", tablepos, &vp->drawmode, false);
 #endif
 #if LCD_DEPTH > 1
-    check_tablevalue(L, "fg_pattern", narg, &vp->fg_pattern, true);
-    check_tablevalue(L, "bg_pattern", narg, &vp->bg_pattern, true);
+    check_tablevalue(L, "fg_pattern", tablepos, &vp->fg_pattern, true);
+    check_tablevalue(L, "bg_pattern", tablepos, &vp->bg_pattern, true);
 #endif
 
     return vp;
@@ -1324,9 +247,9 @@ static inline struct viewport* opt_viewport(lua_State *L,
 
 RB_WRAP(set_viewport)
 {
-    static struct viewport vp;
+    struct viewport *vp = opt_viewport(L, 1, NULL);
     int screen = luaL_optint(L, 2, SCREEN_MAIN);
-    rb->screens[screen]->set_viewport(opt_viewport(L, 1, &vp, NULL));
+    rb->screens[screen]->set_viewport(vp);
     return 0;
 }