source: trunk/liveimg.c @ 237

/*
 *
 * Copyright (C) 2010-2012 <reyalp (at) gmail dot com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
/*
 * functions for handling remote camera display
 *
 */

#if !defined(CHDKPTP_LIVEVIEW)
#error "live view support not enabled"
#endif

#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
#if defined(CHDKPTP_CD)
#include <cd.h>
#include <cdlua.h>
#endif
#include "core/live_view.h"
#include "lbuf.h"
#include "liveimg.h"
/*
planar img
TODO would make sense to use a CD bitmap for this but not public
also may want image handling without CD, but probably want packed rather than planar

TODO if we do packed, might want to make planar and packed use same struct with type flag
*/
typedef struct {
        unsigned width;
        unsigned height;
        uint8_t *data;
        uint8_t *r;
        uint8_t *g;
        uint8_t *b;
        uint8_t *a;
} liveimg_pimg_t;

typedef struct {
        uint8_t r;
        uint8_t g;
        uint8_t b;
        uint8_t a;
} palette_entry_rgba_t;

typedef struct {
        uint8_t a;
        uint8_t y;
        int8_t u;
        int8_t v;
} palette_entry_ayuv_t;

typedef struct {
        int8_t v;
        int8_t u;
        uint8_t y;
        uint8_t a;
} palette_entry_vuya_t;

typedef void (*yuv_palette_to_rgba_fn)(const char *pal_yuv, uint8_t pixel,palette_entry_rgba_t *pal_rgb);

void palette_type1_to_rgba(const char *palette, uint8_t pixel, palette_entry_rgba_t *pal_rgb);
void palette_type2_to_rgba(const char *palette, uint8_t pixel, palette_entry_rgba_t *pal_rgb);
void palette_type3_to_rgba(const char *palette, uint8_t pixel, palette_entry_rgba_t *pal_rgb);

void yuv_live_to_cd_rgb(const char *p_yuv,
                                                unsigned buf_width, unsigned buf_height,
                                                unsigned x_offset, unsigned y_offset,
                                                unsigned width,unsigned height,
                                                int skip,
                                                uint8_t *r,uint8_t *g,uint8_t *b);

// from a540, playback mode
static const char palette_type1_default[]={
0x00, 0x00, 0x00, 0x00, 0xff, 0xe0, 0x00, 0x00, 0xff, 0x60, 0xee, 0x62, 0xff, 0xb9, 0x00, 0x00,
0x7f, 0x00, 0x00, 0x00, 0xff, 0x7e, 0xa1, 0xb3, 0xff, 0xcc, 0xb8, 0x5e, 0xff, 0x5f, 0x00, 0x00,
0xff, 0x94, 0xc5, 0x5d, 0xff, 0x8a, 0x50, 0xb0, 0xff, 0x4b, 0x3d, 0xd4, 0x7f, 0x28, 0x00, 0x00,
0x7f, 0x00, 0x7b, 0xe2, 0xff, 0x30, 0x00, 0x00, 0xff, 0x69, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00,
};

typedef struct {
        yuv_palette_to_rgba_fn to_rgba;
        unsigned num_entries;
} palette_convert_t;

// type implied from index
// TODO only one function for now
palette_convert_t palette_funcs[] = {
        {NULL,0},                                       // type 0 - no palette, we could have a default func here
        {palette_type1_to_rgba,16},     // type 1 - ayuv, 16 entries double 4 bit index
        {palette_type2_to_rgba,16},     // type 2 - like type 1, but with 2 bit alpha lookup - UNTESTED
        {palette_type3_to_rgba,256},    // type 3 - vuya, 256 entries, 2 bit alpha lookup
};

#define N_PALETTE_FUNCS (sizeof(palette_funcs)/sizeof(palette_funcs[0]))

static palette_convert_t* get_palette_convert(unsigned type) {
        if(type<N_PALETTE_FUNCS) {
                return &(palette_funcs[type]);
        }
        return NULL;
}

static unsigned get_palette_size(unsigned type) {
        palette_convert_t* convert = get_palette_convert(type);
        if(convert) {
                return convert->num_entries*4;
        }
        return 0;
}

static uint8_t clip_yuv(int v) {
        if (v<0) return 0;
        if (v>255) return 255;
        return v;
}

static uint8_t yuv_to_r(uint8_t y, int8_t v) {
        return clip_yuv(((y<<12) +          v*5743 + 2048)>>12);
}

static uint8_t yuv_to_g(uint8_t y, int8_t u, int8_t v) {
        return clip_yuv(((y<<12) - u*1411 - v*2925 + 2048)>>12);
}

static uint8_t yuv_to_b(uint8_t y, int8_t u) {
        return clip_yuv(((y<<12) + u*7258          + 2048)>>12);
}

static uint8_t clamp_uint8(unsigned v) {
        return (v>255)?255:v;
}

static int8_t clamp_int8(int v) {
        if(v>127) {
                return 127;
        }
        if(v<-128) {
                return -128;
        }
        return v;
}

void palette_type1_to_rgba(const char *palette, uint8_t pixel,palette_entry_rgba_t *pal_rgb) {
        const palette_entry_ayuv_t *pal = (const palette_entry_ayuv_t *)palette;
        unsigned i1 = pixel & 0xF;
        unsigned i2 = (pixel & 0xF0)>>4;
        int8_t u,v;
        uint8_t y;
        pal_rgb->a = (pal[i1].a + pal[i2].a)>>1;
        // TODO not clear if these should be /2 or not
        y = clamp_uint8(pal[i1].y + pal[i2].y);
        u = clamp_int8(pal[i1].u + pal[i2].u);
        v = clamp_int8(pal[i1].v + pal[i2].v);
        pal_rgb->r = yuv_to_r(y,v);
        pal_rgb->g = yuv_to_g(y,u,v);
        pal_rgb->b = yuv_to_b(y,u);
}

static const uint8_t alpha2_lookup[] = {128,171,214,255};
// like above, but with alpha lookup
void palette_type2_to_rgba(const char *palette, uint8_t pixel,palette_entry_rgba_t *pal_rgb) {
        const palette_entry_ayuv_t *pal = (const palette_entry_ayuv_t *)palette;
        unsigned i1 = pixel & 0xF;
        unsigned i2 = (pixel & 0xF0)>>4;
        int8_t u,v;
        uint8_t y;
        uint8_t a = (pal[i1].a + pal[i2].a)>>1;
        pal_rgb->a = alpha2_lookup[a&3];
        // TODO not clear if these should be /2 or not
        y = clamp_uint8(pal[i1].y + pal[i2].y);
        u = clamp_int8(pal[i1].u + pal[i2].u);
        v = clamp_int8(pal[i1].v + pal[i2].v);
        pal_rgb->r = yuv_to_r(y,v);
        pal_rgb->g = yuv_to_g(y,u,v);
        pal_rgb->b = yuv_to_b(y,u);
}

void palette_type3_to_rgba(const char *palette, uint8_t pixel,palette_entry_rgba_t *pal_rgb) {
        const palette_entry_vuya_t *pal = (const palette_entry_vuya_t *)palette;
        // special case for index 0
        if(pixel == 0) {
                pal_rgb->a = pal_rgb->r = pal_rgb->g = pal_rgb->b = 0;
                return;
        }
        pal_rgb->a = alpha2_lookup[pal[pixel].a&3];
        pal_rgb->r = yuv_to_r(pal[pixel].y,pal[pixel].v);
        pal_rgb->g = yuv_to_g(pal[pixel].y,pal[pixel].u,pal[pixel].v);
        pal_rgb->b = yuv_to_b(pal[pixel].y,pal[pixel].u);
}

void yuv_live_to_cd_rgb(const char *p_yuv,
                                                unsigned buf_width, unsigned buf_height,
                                                unsigned x_offset, unsigned y_offset,
                                                unsigned width,unsigned height,
                                                int skip,
                                                uint8_t *r,uint8_t *g,uint8_t *b) {
        unsigned x,row;
        unsigned row_inc = (buf_width*12)/8;
        const char *p;
        // start at end to flip for CD
        const char *p_row = p_yuv + (height + y_offset - 1) * row_inc + (x_offset*12)/8;
        for(row=0;row<height;row++,p_row -= row_inc) {
                for(x=0,p=p_row;x<width;x+=4,p+=6) {
                        *r++ = yuv_to_r(p[1],p[2]);
                        *g++ = yuv_to_g(p[1],p[0],p[2]);
                        *b++ = yuv_to_b(p[1],p[0]);

                        *r++ = yuv_to_r(p[3],p[2]);
                        *g++ = yuv_to_g(p[3],p[0],p[2]);
                        *b++ = yuv_to_b(p[3],p[0]);
                        if(!skip) {
                                // TODO it might be better to use the next pixels U and V values
                                *r++ = yuv_to_r(p[4],p[2]);
                                *g++ = yuv_to_g(p[4],p[0],p[2]);
                                *b++ = yuv_to_b(p[4],p[0]);

                                *r++ = yuv_to_r(p[5],p[2]);
                                *g++ = yuv_to_g(p[5],p[0],p[2]);
                                *b++ = yuv_to_b(p[5],p[0]);
                        }
                }
        }
}

static void pimg_destroy(liveimg_pimg_t *im) {
        free(im->data);
        im->width = im->height = 0;
        im->data = im->r = im->g = im->b = im->a = NULL;
}

static int pimg_gc(lua_State *L) {
        liveimg_pimg_t *im = (liveimg_pimg_t *)luaL_checkudata(L,1,LIVEIMG_PIMG_META);
        pimg_destroy(im);
        return 0;
}

static int pimg_get_width(lua_State *L) {
        liveimg_pimg_t *im = (liveimg_pimg_t *)luaL_checkudata(L,1,LIVEIMG_PIMG_META);
        if(!im->data) {
                return luaL_error(L,"dead pimg");
        }
        lua_pushnumber(L,im->width);
        return 1;
}

static int pimg_get_height(lua_State *L) {
        liveimg_pimg_t *im = (liveimg_pimg_t *)luaL_checkudata(L,1,LIVEIMG_PIMG_META);
        if(!im->data) {
                return luaL_error(L,"dead pimg");
        }
        lua_pushnumber(L,im->height);
        return 1;
}

static int pimg_kill(lua_State *L) {
        liveimg_pimg_t *im = (liveimg_pimg_t *)luaL_checkudata(L,1,LIVEIMG_PIMG_META);
        pimg_destroy(im);
        return 0;
}

/*
create a new pimg and push it on the stack
TODO might want to pass in width, height or data, but need to handle rgb vs rgba
*/
int pimg_create(lua_State *L) {
        liveimg_pimg_t *im = (liveimg_pimg_t *)lua_newuserdata(L,sizeof(liveimg_pimg_t));
        if(!im) {
                return 0;
        }
        im->width = im->height = 0;
        im->data = im->r = im->g = im->b = im->a = NULL;
        luaL_getmetatable(L, LIVEIMG_PIMG_META);
        lua_setmetatable(L, -2);

        return 1;
}

int pimg_init_rgb(liveimg_pimg_t *im,unsigned width,unsigned height) {
        unsigned size = width*height;
        if(!size) {
                return 0;
        }
        im->data=malloc(size*3);
        if(!im->data) {
                return 0;
        }
        im->width = width;
        im->height = height;
        im->r=im->data;
        im->g=im->r+size;
        im->b=im->g+size;
        im->a=NULL;
        return 1;
}

/*
TODO stupid copy/paste
*/
int pimg_init_rgba(liveimg_pimg_t *im,unsigned width,unsigned height) {
        unsigned size = width*height;
        if(!size) {
                return 0;
        }
        im->data=malloc(size*4);
        if(!im->data) {
                return 0;
        }
        im->width = width;
        im->height = height;
        im->r=im->data;
        im->g=im->r+size;
        im->b=im->g+size;
        im->a=im->b+size;
        return 1;
}

/*
check whether given stack index is an pimg, and if so, return it
*/
liveimg_pimg_t * pimg_get(lua_State *L,int i) {
        if(!lua_isuserdata(L,i)) {
                return NULL;
        }
        if(lua_islightuserdata(L,i)) {
                return NULL;
        }
        if(!lua_getmetatable(L,i)) {
                return NULL;
        }
        lua_getfield(L,LUA_REGISTRYINDEX,LIVEIMG_PIMG_META);
        int r = lua_rawequal(L,-1,-2);
        lua_pop(L,2);
        if(r) {
                return lua_touserdata(L,i);
        }
        return NULL;
}

/*
convert viewport data to RGB pimg
pimg=liveimg.get_viewport_pimg(pimg,base_info,vid_info,skip)
pimg: pimg to re-use, created if nil, replaced if size doesn't match
vid_info, base_info: from handler
skip: boolean - if true, each U Y V Y Y Y is converted to 2 pixels, otherwise 4
returns nil if info does not contain a live view
*/
static int liveimg_get_viewport_pimg(lua_State *L) {
        lv_vid_info *vi;
        lv_base_info *bi;
        liveimg_pimg_t *im = pimg_get(L,1);
        lBuf_t *base_lb = luaL_checkudata(L,2,LBUF_META);
        lBuf_t *vi_lb = luaL_checkudata(L,3,LBUF_META);
        int skip = lua_toboolean(L,4);
        // pixel aspect ratio
        int par = (skip == 1)?2:1;

        bi = (lv_base_info *)base_lb->bytes;
        vi = (lv_vid_info *)vi_lb->bytes;

        // this is not currently an error, if sent live data without viewport selected, just return nil image
        if(!vi->vp_buffer_start) {
                lua_pushnil(L);
                return 1;
        }

        unsigned vwidth = vi->vp_width/par;
        unsigned dispsize = vwidth*vi->vp_height;

        // sanity checks - TODO might want to have this standalone somewhere
        if(vi->vp_buffer_start + (bi->vp_buffer_width*bi->vp_max_height*12)/8 > vi_lb->len) {
                return luaL_error(L,"data < buffer_width*max_height");
        }

        if(vi->vp_height + vi->vp_yoffset > bi->vp_max_height) {
                return luaL_error(L,"vp_height + vp_yoffset > vp_max_height");
        }

        if(vi->vp_width + vi->vp_xoffset > bi->vp_buffer_width) {
                return luaL_error(L,"vp_width + vp_xoffset > vp_buffer_width");
        }

        if(im && dispsize != im->width*im->height) {
                pimg_destroy(im);
                im = NULL;
        }
        if(im) {
                lua_pushvalue(L, 1); // copy im onto top for return
        } else { // create an new im 
                pimg_create(L);
                im = luaL_checkudata(L,-1,LIVEIMG_PIMG_META);
                if(!pimg_init_rgb(im,vwidth,vi->vp_height)) {
                        return luaL_error(L,"failed to create image");
                }
        }

        yuv_live_to_cd_rgb(vi_lb->bytes+vi->vp_buffer_start,
                                                bi->vp_buffer_width,
                                                bi->vp_max_height,
                                                vi->vp_xoffset,
                                                vi->vp_yoffset,
                                                vi->vp_width,
                                                vi->vp_height,
                                                skip,
                                                im->r,im->g,im->b);
        return 1;
}

/*
check framebuffer desc values, and return a descriptive error or NULL
TODO can't check total size without bpp
*/
static const char * check_fb_desc(lv_framebuffer_desc *desc) {
        if(desc->visible_height > desc->buffer_height) {
                return "height > buffer_height";
        }

        if(desc->visible_width > desc->buffer_width) {
                return "width  > buffer_width";
        }
        // sanity check, this should actually be harmless 
        if(desc->visible_width > desc->logical_width) {
                return "visible_width > logical_width";
        }
        if(desc->visible_height > desc->logical_height) {
                return "visible_height > logical_height";
        }
        return NULL;
}

/*
convert viewport data to RGB pimg
pimg=liveimg.get_viewport2_pimg(pimg,live_frame,skip)
pimg: pimg to re-use, created if nil, replaced if size doesn't match
live_fream: from get_live_data
skip: boolean - if true, each U Y V Y Y Y is converted to 2 pixels, otherwise 4
returns nil if info does not contain a live view
*/
static int liveimg_get_viewport2_pimg(lua_State *L) {
        lv_data_header *frame;
        liveimg_pimg_t *im = pimg_get(L,1);
        lBuf_t *frame_lb = luaL_checkudata(L,2,LBUF_META);
        int skip = lua_toboolean(L,3);
        // pixel aspect ratio
        int par = (skip == 1)?2:1;

        frame = (lv_data_header *)frame_lb->bytes;

        // this is not currently an error, if sent live data without viewport selected, just return nil image
        if(!frame->vp.data_start) {
                lua_pushnil(L);
                return 1;
        }

        unsigned vwidth = frame->vp.visible_width/par;
        unsigned dispsize = vwidth*frame->vp.visible_height;

        // sanity check size - depends on type
        if(frame->vp.data_start + (frame->vp.buffer_width*frame->vp.buffer_height*12)/8 > frame_lb->len) {
                return luaL_error(L,"data < buffer_width*buffer_height");
        }
        const char *fb_desc_err = check_fb_desc(&frame->vp);
        if(fb_desc_err) {
                return luaL_error(L,fb_desc_err);
        }

        if(im && dispsize != im->width*im->height) {
                pimg_destroy(im);
                im = NULL;
        }
        if(im) {
                lua_pushvalue(L, 1); // copy im onto top for return
                // set width and height, could have changed without changing byte count
                im->width = vwidth;
                im->height = frame->vp.visible_height;
        } else { // create an new im 
                pimg_create(L);
                im = luaL_checkudata(L,-1,LIVEIMG_PIMG_META);
                if(!pimg_init_rgb(im,vwidth,frame->vp.visible_height)) {
                        return luaL_error(L,"failed to create image");
                }
        }

        yuv_live_to_cd_rgb(frame_lb->bytes+frame->vp.data_start,
                                                frame->vp.buffer_width,
                                                frame->vp.buffer_height,
                                                0,
                                                0,
                                                frame->vp.visible_width,
                                                frame->vp.visible_height,
                                                skip,
                                                im->r,im->g,im->b);
        return 1;
}

static void convert_palette(palette_entry_rgba_t *pal_rgba,lv_vid_info *vi) {
        const char *pal=NULL;
        palette_convert_t *convert=get_palette_convert(vi->palette_type);
        if(!convert || !vi->palette_buffer_start) {
                convert = get_palette_convert(1);
                pal = palette_type1_default;
        } else {
                pal = ((char *)vi + vi->palette_buffer_start);
        }
        yuv_palette_to_rgba_fn fn = convert->to_rgba;
        int i;
        for(i=0;i<256;i++) {
                fn(pal,i,&pal_rgba[i]);
        }
}

/*
convert bitmap data to RGBA pimg
pimg=liveimg.get_bitmap_pimg(pimg,base_info,vid_info,skip)
pimg: pimg to re-use, created if nil, replaced if size doesn't match
vid_info, base_info: from handler
skip: boolean - if true, every other pixel in the x axis is discarded (for viewports with a 1:2 par)
returns nil if info does not contain a bitmap
*/
static int liveimg_get_bitmap_pimg(lua_State *L) {
        palette_entry_rgba_t pal_rgba[256];

        lv_vid_info *vi;
        lv_base_info *bi;
        liveimg_pimg_t *im = pimg_get(L,1);
        lBuf_t *base_lb = luaL_checkudata(L,2,LBUF_META);
        lBuf_t *vi_lb = luaL_checkudata(L,3,LBUF_META);
        int skip = lua_toboolean(L,4);
        // pixel aspect ratio
        int par = (skip == 1)?2:1;

        bi = (lv_base_info *)base_lb->bytes;
        vi = (lv_vid_info *)vi_lb->bytes;

        if(!vi->bm_buffer_start) {
                lua_pushnil(L);
                return 1;
        }

        if(bi->bm_max_height*bi->bm_max_width + vi->bm_buffer_start > vi_lb->len) {
                return luaL_error(L,"data < max_height*max_width");
        }

        if(get_palette_size(vi->palette_type) + vi->palette_buffer_start > vi_lb->len) {
                return luaL_error(L,"data < palette size");
        }

        convert_palette(pal_rgba,vi);

        unsigned vwidth = bi->bm_max_width/par;
        unsigned dispsize = vwidth*bi->bm_max_height;


        if(im && dispsize != im->width*im->height) {
                pimg_destroy(im);
                im = NULL;
        }
        if(im) {
                lua_pushvalue(L, 1); // copy im onto top for return
        } else { // create an new im 
                pimg_create(L);
                im = luaL_checkudata(L,-1,LIVEIMG_PIMG_META);
                if(!pimg_init_rgba(im,vwidth,bi->bm_max_height)) {
                        return luaL_error(L,"failed to create image");
                }
        }

        int y_inc = bi->bm_buffer_width;
        int x_inc = par;
        int x,y;
        int height = bi->bm_max_height;

        uint8_t *p=((uint8_t *)vi + vi->bm_buffer_start) + (height-1)*y_inc;

        uint8_t *r = im->r;
        uint8_t *g = im->g;
        uint8_t *b = im->b;
        uint8_t *a = im->a;

        for(y=0;y<height;y++,p-=y_inc) {
                for(x=0;x<bi->bm_max_width;x+=x_inc) {
                        palette_entry_rgba_t *c =&pal_rgba[*(p+x)];
                        *r++ = c->r;
                        *g++ = c->g;
                        *b++ = c->b;
                        *a++ = c->a;
                }
        }
        return 1;
}

static void convert_palette2(palette_entry_rgba_t *pal_rgba,lv_data_header *frame) {
        const char *pal=NULL;
        palette_convert_t *convert=get_palette_convert(frame->palette_type);
        if(!convert || !frame->palette_data_start) {
                convert = get_palette_convert(1);
                pal = palette_type1_default;
        } else {
                pal = ((char *)frame + frame->palette_data_start);
        }
        yuv_palette_to_rgba_fn fn = convert->to_rgba;
        int i;
        for(i=0;i<256;i++) {
                fn(pal,i,&pal_rgba[i]);
        }
}

/*
convert bitmap data to RGBA pimg
pimg=liveimg.get_bitmap2_pimg(pimg,frame,skip)
pimg: pimg to re-use, created if nil, replaced if size doesn't match
frame: from live_get_data
skip: boolean - if true, every other pixel in the x axis is discarded (for viewports with a 1:2 par)
returns nil if info does not contain a bitmap
*/
static int liveimg_get_bitmap2_pimg(lua_State *L) {
        palette_entry_rgba_t pal_rgba[256];

        lv_data_header *frame;
        liveimg_pimg_t *im = pimg_get(L,1);
        lBuf_t *frame_lb = luaL_checkudata(L,2,LBUF_META);
        int skip = lua_toboolean(L,3);
        // pixel aspect ratio
        int par = (skip == 1)?2:1;

        frame = (lv_data_header *)frame_lb->bytes;

        if(!frame->bm.data_start) {
                lua_pushnil(L);
                return 1;
        }

        // sanity check size - depends on type
        if(frame->bm.data_start + frame->bm.buffer_width*frame->bm.buffer_height > frame_lb->len) {
                return luaL_error(L,"data < buffer_width*buffer_height");
        }

        const char *fb_desc_err = check_fb_desc(&frame->bm);
        if(fb_desc_err) {
                return luaL_error(L,fb_desc_err);
        }

        if(get_palette_size(frame->palette_type) + frame->palette_data_start > frame_lb->len) {
                return luaL_error(L,"data < palette size");
        }

        convert_palette2(pal_rgba,frame);

        unsigned vwidth = frame->bm.visible_width/par;
        unsigned dispsize = vwidth*frame->bm.visible_height;


        if(im && dispsize != im->width*im->height) {
                pimg_destroy(im);
                im = NULL;
        }
        if(im) {
                lua_pushvalue(L, 1); // copy im onto top for return
        } else { // create an new im 
                pimg_create(L);
                im = luaL_checkudata(L,-1,LIVEIMG_PIMG_META);
                if(!pimg_init_rgba(im,vwidth,frame->bm.visible_height)) {
                        return luaL_error(L,"failed to create image");
                }
        }

        int y_inc = frame->bm.buffer_width;
        int x_inc = par;
        int x,y;
        int height = frame->bm.visible_height;

        uint8_t *p=((uint8_t *)frame_lb->bytes + frame->bm.data_start) + (height-1)*y_inc;

        uint8_t *r = im->r;
        uint8_t *g = im->g;
        uint8_t *b = im->b;
        uint8_t *a = im->a;

        // TODO we don't actually check the various offsets
        for(y=0;y<height;y++,p-=y_inc) {
                for(x=0;x<frame->bm.visible_width;x+=x_inc) {
                        palette_entry_rgba_t *c =&pal_rgba[*(p+x)];
                        *r++ = c->r;
                        *g++ = c->g;
                        *b++ = c->b;
                        *a++ = c->a;
                }
        }
        return 1;
}

#if defined(CHDKPTP_CD)
/*
pimg:put_to_cd_canvas(canvas, x, y, width, height, xmin, xmax, ymin, ymax)
*/
static int pimg_put_to_cd_canvas(lua_State *L) {
        liveimg_pimg_t *im = (liveimg_pimg_t *)luaL_checkudata(L,1,LIVEIMG_PIMG_META);
        cdCanvas *cnv = cdlua_checkcanvas(L,2);
        if(!im->data) {
                return luaL_error(L,"dead pimg");
        }
        // left, bottom
        int x=luaL_optint(L,3,0);
        int y=luaL_optint(L,4,0);
        // target width, height. 0 = default
        int width=luaL_optint(L,5,0);
        int height=luaL_optint(L,6,0);
        // sub image
        int xmin=luaL_optint(L,7,0);
        int xmax=luaL_optint(L,8,0);
        int ymin=luaL_optint(L,9,0);
        int ymax=luaL_optint(L,10,0);
        cdCanvasPutImageRectRGB(cnv,
                                                        im->width,im->height, // image size
                                                        im->r,im->g,im->b, // data
                                                        x,y,
                                                        width,height,
                                                        xmin,xmax,ymin,ymax);
        return 0;
}

/*
as above, but with alpha
*/
static int pimg_blend_to_cd_canvas(lua_State *L) {
        liveimg_pimg_t *im = (liveimg_pimg_t *)luaL_checkudata(L,1,LIVEIMG_PIMG_META);
        cdCanvas *cnv = cdlua_checkcanvas(L,2);
        if(!im->data) {
                return luaL_error(L,"dead pimg");
        }
        if(!im->a) {
                return luaL_error(L,"pimg has no alpha channel");
        }
        // left, bottom
        int x=luaL_optint(L,3,0);
        int y=luaL_optint(L,4,0);
        // target width, height. 0 = default
        int width=luaL_optint(L,5,0);
        int height=luaL_optint(L,6,0);
        // sub image
        int xmin=luaL_optint(L,7,0);
        int xmax=luaL_optint(L,8,0);
        int ymin=luaL_optint(L,9,0);
        int ymax=luaL_optint(L,10,0);
        cdCanvasPutImageRectRGBA(cnv,
                                                        im->width,im->height, // image size
                                                        im->r,im->g,im->b,im->a, // data
                                                        x,y,
                                                        width,height,
                                                        xmin,xmax,ymin,ymax);
        return 0;
}

#endif

static const luaL_Reg liveimg_funcs[] = {
  {"get_bitmap_pimg", liveimg_get_bitmap_pimg},
  {"get_bitmap2_pimg", liveimg_get_bitmap2_pimg},
  {"get_viewport_pimg", liveimg_get_viewport_pimg},
  {"get_viewport2_pimg", liveimg_get_viewport2_pimg},
  {NULL, NULL}
};

static const luaL_Reg pimg_methods[] = {
#if defined(CHDKPTP_CD)
  {"put_to_cd_canvas", pimg_put_to_cd_canvas},
  {"blend_to_cd_canvas", pimg_blend_to_cd_canvas},
#endif
  {"width", pimg_get_width},
  {"height", pimg_get_height},
  {"kill", pimg_kill},
  {NULL, NULL}
};

static const luaL_Reg pimg_meta_methods[] = {
  {"__gc", pimg_gc},
  {NULL, NULL}
};

// TODO based on lbuf,
// would be nice to have a way to extend lbuf with additional custom bindings
void liveimg_open(lua_State *L) {
        luaL_newmetatable(L,LIVEIMG_PIMG_META);
        luaL_register(L, NULL, pimg_meta_methods);  

        /* use a table of methods for the __index method */
        lua_newtable(L);
        luaL_register(L, NULL, pimg_methods);  
        lua_setfield(L,-2,"__index");

        /* global lib */
        lua_newtable(L);
        luaL_register(L, "liveimg", liveimg_funcs);  
        lua_pop(L,3);
}