LuatOS/luat/modules/luat_lib_zbuff.c

/*
@module  zbuff
@summary c内存数据操作库
@version 0.1
@date    2021.03.31
@video https://www.bilibili.com/video/BV1gr4y1V7HN
@tag LUAT_USE_ZBUFF
@demo  zbuff
*/
#include "luat_base.h"
#include "luat_zbuff.h"

#define LUAT_LOG_TAG "zbuff"
#include "luat_log.h"

#ifndef LUAT_CONF_ZBUFF_DEFAULT_TYPE
#ifdef LUAT_USE_PSRAM
#define LUAT_CONF_ZBUFF_DEFAULT_TYPE LUAT_HEAP_PSRAM
#else
#define LUAT_CONF_ZBUFF_DEFAULT_TYPE LUAT_HEAP_SRAM
#endif
#endif

//在buff对象后添加数据，返回增加的字节数
static int add_bytes(luat_zbuff_t *buff, const char *source, size_t len)
{
    if (buff->len - buff->cursor < len)
        len = buff->len - buff->cursor;
    memcpy(buff->addr + buff->cursor, source, len);
    buff->cursor += len;
    return len;
}

#define SET_POINT_1(buff, point, color)                \
    if (color % 2)                                     \
        buff->addr[point / 8] |= 1 << (7 - point % 8); \
    else                                               \
        buff->addr[point / 8] &= ~(1 << (7 - point % 8))
#define SET_POINT_4(buff, point, color)                 \
    buff->addr[point / 2] &= (point % 2) ? 0xf0 : 0x0f; \
    buff->addr[point / 2] |= (point % 2) ? color : (color * 0x10)
#define SET_POINT_8(buff, point, color) buff->addr[point] = color
#define SET_POINT_16(buff, point, color) \
    buff->addr[point * 2] = color / 0x100;   \
    buff->addr[point * 2 + 1] = color % 0x100
#define SET_POINT_24(buff, point, color)                              \
    buff->addr[point * 3] = color / 0x10000;                          \
    buff->addr[point * 3 + 1] = color % 0x10000 / 0x100; \
    buff->addr[point * 3 + 2] = color % 0x100
#define SET_POINT_32(buff, point, color)                 \
    buff->addr[point] = color / 0x1000000;               \
    buff->addr[point + 1] = color % 0x1000000 / 0x10000; \
    buff->addr[point + 2] = color % 0x10000 / 0x100;     \
    buff->addr[point + 3] = color % 0x100

#define SET_POINT_CASE(n, point, color)    \
    case n:                                \
        SET_POINT_##n(buff, point, color); \
        break
//更改某点的颜色
#define set_framebuffer_point(buff, point, color) \
    switch (buff->bit)                            \
    {                                             \
        SET_POINT_CASE(1, (point), (color));      \
        SET_POINT_CASE(4, (point), (color));      \
        SET_POINT_CASE(8, (point), (color));      \
        SET_POINT_CASE(16, (point), (color));     \
        SET_POINT_CASE(24, (point), (color));     \
        SET_POINT_CASE(32, (point), (color));     \
    default:                                      \
        break;                                    \
    }

#define GET_POINT_1(buff, point) (buff->addr[point / 8] >> (7 - point % 8)) % 2
#define GET_POINT_4(buff, point) (buff->addr[point / 2] >> ((point % 2) ? 0 : 4)) % 0x10
#define GET_POINT_8(buff, point) buff->addr[point]
#define GET_POINT_16(buff, point) buff->addr[point * 2] * 0x100 + buff->addr[point * 2 + 1]
#define GET_POINT_24(buff, point) \
    buff->addr[point * 3] * 0x10000 + buff->addr[point * 3 + 1] * 0x100 + buff->addr[point * 3 + 2]
#define GET_POINT_32(buff, point) \
    buff->addr[point] * 0x1000000 + buff->addr[point + 1] * 0x10000 + buff->addr[point + 2] * 0x100 + buff->addr[point + 3]
#define GET_POINT_CASE(n, point)           \
    case n:                                \
        return GET_POINT_##n(buff, point); \

//获取某点的颜色
static uint32_t get_framebuffer_point(luat_zbuff_t *buff,uint32_t point)
{
    switch (buff->bit)
    {
        GET_POINT_CASE(1, point);
        GET_POINT_CASE(4, point);
        GET_POINT_CASE(8, point);
        GET_POINT_CASE(16, point);
        GET_POINT_CASE(24, point);
        GET_POINT_CASE(32, point);
    default:
        break;
    }
    return 0;
}

/**
创建zbuff
@api zbuff.create(length,data,type)
@int 字节数
@any 可选参数，number时为填充数据，string时为填充字符串
@number 可选参数，内存类型默认自动选择
@return object zbuff对象，如果创建失败会返回nil
@usage
-- 创建zbuff
local buff = zbuff.create(1024) -- 空白的
local buff = zbuff.create(1024, 0x33) --创建一个初值全为0x33的内存区域
local buff = zbuff.create(1024, "123321456654") -- 创建，并填充一个已有字符串的内容

-- 创建framebuff用的zbuff
-- zbuff.create({width,height,bit},data,type)
-- table 宽度、高度、色位深度
@int 可选参数，填充数据
@number 可选参数，内存类型
@return object zbuff对象，如果创建失败会返回nil
@usage
-- 创建zbuff
local buff = zbuff.create({128,160,16})--创建一个128*160的framebuff
local buff = zbuff.create({128,160,16},0xf800)--创建一个128*160的framebuff，初始状态红色
 */
static int l_zbuff_create(lua_State *L)
{
    size_t len;
    uint32_t width = 0,height = 0;
    uint8_t bit = 0;
    if (lua_istable(L, 1)){
        lua_rawgeti(L, 1, 3);
        lua_rawgeti(L, 1, 2);
        lua_rawgeti(L, 1, 1);
        width = luaL_checkinteger(L, -1);
        height = luaL_checkinteger(L, -2);
        bit = luaL_checkinteger(L, -3);
        if (bit != 1 && bit != 4 && bit != 8 && bit != 16 && bit != 24 && bit != 32) return 0;
        len = (width * height * bit - 1) / 8 + 1;
        lua_pop(L, 3);
    } else {
        len = luaL_checkinteger(L, 1);
    }
    if (len <= 0) return 0;

    if (len >= 64*1024) {
        LLOGI("create large size: %d kbyte, trigger force GC", len / 1024);
        lua_gc(L, LUA_GCCOLLECT, 0);
        lua_gc(L, LUA_GCCOLLECT, 0);
    }

    luat_zbuff_t *buff = (luat_zbuff_t *)lua_newuserdata(L, sizeof(luat_zbuff_t));
    if (buff == NULL) return 0;

    if (lua_isinteger(L, 3)){
    	buff->type = luaL_optinteger(L, 3, LUAT_CONF_ZBUFF_DEFAULT_TYPE);
    } else {
        buff->type = LUAT_CONF_ZBUFF_DEFAULT_TYPE;
    }
    buff->addr = (uint8_t *)luat_heap_opt_malloc(buff->type,len);
    if (buff->addr == NULL){
        // 尝试垃圾回收后再分配一次
        LLOGI("create size: %d byte but memory not enough, trigger GC", len);
        lua_gc(L, LUA_GCCOLLECT, 0);
        lua_gc(L, LUA_GCCOLLECT, 0);
        buff->addr = (uint8_t *)luat_heap_opt_malloc(buff->type,len);
    }
    if (buff->addr == NULL){
        LLOGW("create size: %d byte but memory not enough!!!", len);
        lua_pushnil(L);
        lua_pushstring(L, "memory not enough");
        return 2;
    }

    buff->len = len;
    buff->cursor = 0;

    if (lua_istable(L, 1)){
        buff->width = width;
        buff->height = height;
        buff->bit = bit;
        if (lua_isinteger(L, 2)){
            LUA_INTEGER initial = luaL_checkinteger(L, 2);
            uint32_t i;
            for (i = 0; i < buff->width * buff->height; i++){
                set_framebuffer_point(buff, i, initial);
            }
        }
    }else{
        buff->width = buff->height = buff->bit = 0;
        if (lua_isinteger(L, 2)){
            memset(buff->addr, luaL_checkinteger(L, 2) % 0x100, len);
        }
        else if (lua_isstring(L, 2)){
            const char *data = luaL_optlstring(L, 2, "", &len);
            if (len > buff->len) len = buff->len; //防止越界
            memcpy(buff->addr, data, len);
            buff->cursor = len;
        }else{
            memset(buff->addr, 0, len);
        }
    }

    luaL_setmetatable(L, LUAT_ZBUFF_TYPE);
    return 1;
}

/**
zbuff写数据（从当前指针位置开始；执行后指针会向后移动）
@api buff:write(para,...)
@any 写入buff的数据，string时为一个参数，number时可为多个参数
@return number 数据成功写入的长度
@usage
-- 类file的读写操作
local len = buff:write("123") -- 写入数据, 指针相应地往后移动，返回写入的数据长度
local len = buff:write(0x1a,0x30,0x31,0x32,0x00,0x01)  -- 按数值写入多个字节数据
 */
static int l_zbuff_write(lua_State *L)
{
    if (lua_isinteger(L, 2))
    {
        int len = 0;
        int data = 0;
        luat_zbuff_t *buff = tozbuff(L);
        while (lua_isinteger(L, 2 + len) && buff->cursor < buff->len)
        {
            data = luaL_checkinteger(L, 2 + len);
            *(uint8_t *)(buff->addr + buff->cursor) = data % 0x100;
            buff->cursor++;
            len++;
        }
        lua_pushinteger(L, len);
        return 1;
    }
    else
    {
        size_t len;
        const char *data = luaL_checklstring(L, 2, &len);
        luat_zbuff_t *buff = tozbuff(L);
        if (len + buff->cursor > buff->len) //防止越界
        {
            len = buff->len - buff->cursor;
        }
        memcpy(buff->addr + buff->cursor, data, len);
        buff->cursor = buff->cursor + len;
        lua_pushinteger(L, len);
        return 1;
    }
}

/**
zbuff读数据（从当前指针位置开始；执行后指针会向后移动）
@api buff:read(length)
@int 读取buff中的字节数
@return string 读取结果
@usage
-- 类file的读写操作
local str = buff:read(3)
 */
static int l_zbuff_read(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    int read_num = luaL_optinteger(L, 2, 1);
    if (read_num > buff->len - buff->cursor) //防止越界
    {
        read_num = buff->len - buff->cursor;
    }
    if (read_num <= 0)
    {
        lua_pushlstring(L, NULL, 0);
        return 1;
    }
    char *return_str = (char *)luat_heap_opt_malloc(buff->type,read_num);
    if (return_str == NULL)
    {
        return 0;
    }
    memcpy(return_str, buff->addr + buff->cursor, read_num);
    lua_pushlstring(L, return_str, read_num);
    buff->cursor += read_num;
    luat_heap_opt_free(buff->type, return_str);
    return 1;
}

/**
zbuff清空数据（与当前指针位置无关；执行后指针位置不变）
@api buff:clear(num)
@int 可选，默认为0。要设置为的值，不会改变buff指针位置
@usage
-- 全部初始化为0
buff:clear(0)
 */
static int l_zbuff_clear(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    int num = luaL_optinteger(L, 2, 0);
    memset(buff->addr, num % 0x100, buff->len);
    return 0;
}

/**
zbuff设置光标位置（可能与当前指针位置有关；执行后指针会被设置到指定位置）
@api buff:seek(offset, base)
@int 偏移长度
@int where, 基点，默认zbuff.SEEK_SET。zbuff.SEEK_SET: 基点为 0 （文件开头），zbuff.SEEK_CUR: 基点为当前位置，zbuff.SEEK_END: 基点为文件尾
@return int 设置光标后从buff开头计算起的光标的位置
@usage
buff:seek(0) -- 把光标设置到指定位置
buff:seek(5,zbuff.SEEK_CUR)
buff:seek(-3,zbuff.SEEK_END)
 */
static int l_zbuff_seek(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);

    int offset = luaL_checkinteger(L, 2);
    int whence = luaL_optinteger(L, 3, ZBUFF_SEEK_SET);
    switch (whence)
    {
    case ZBUFF_SEEK_SET:
        break;
    case ZBUFF_SEEK_CUR:
        offset = buff->cursor + offset;
        break;
    case ZBUFF_SEEK_END:
        offset = buff->len + offset;
        break;
    default:
        return 0;
    }
    if (offset <= 0)
        offset = 0;
    if (offset > buff->len)
        offset = buff->len;
    buff->cursor = offset;
    lua_pushinteger(L, buff->cursor);
    return 1;
}

//code from https://github.com/LuaDist/lpack/blob/master/lpack.c
#define	OP_STRING	'A'
#define	OP_FLOAT	'f'
#define	OP_DOUBLE	'd'
#define	OP_NUMBER	'n'
#define	OP_CHAR		'c'
#define	OP_BYTE		'b'
#define	OP_SHORT	'h'
#define	OP_USHORT	'H'
#define	OP_INT		'i'
#define	OP_UINT		'I'
#define	OP_LONG		'l'
#define	OP_ULONG	'L'
#define	OP_LITTLEENDIAN	'<'
#define	OP_BIGENDIAN	'>'
#define	OP_NATIVE	'='

#define isdigit(c) ((c) >= '0' && (c) <= '9')
static void badcode(lua_State *L, int c)
{
    char s[]="bad code `?'";
    s[sizeof(s)-3]=c;
    luaL_argerror(L,1,s);
}
static int doendian(int c)
{
    int x=1;
    int e=*(char*)&x;
    if (c==OP_LITTLEENDIAN) return !e;
    if (c==OP_BIGENDIAN) return e;
    if (c==OP_NATIVE) return 0;
    return 0;
}
static void doswap(int swap, void *p, size_t n)
{
    if (swap)
    {
        char *a = p;
        int i, j;
        for (i = 0, j = n - 1, n = n / 2; n--; i++, j--)
        {
            char t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
}

/**
将一系列数据按照格式字符转化，并写入（从当前指针位置开始；执行后指针会向后移动）
@api buff:pack(format,val1, val2,...)
@string 后面数据的格式（符号含义见下面的例子）
@val  传入的数据，可以为多个数据
@return int 成功写入的数据长度
@usage
buff:pack(">IIHA", 0x1234, 0x4567, 0x12,"abcdefg") -- 按格式写入几个数据
-- A string
-- f float
-- d double
-- n Lua number
-- c char
-- b byte / unsignen char
-- h short
-- H unsigned short
-- i int
-- I unsigned int
-- l long
-- L unsigned long
-- < 小端
-- > 大端
-- = 默认大小端

-- 例子
buff:pack(
">IIHA", -- 格式字符串：大端序，依次为[4字节无符号整型, 4字节无符号整型, 2字节无符号短整型, 字符串]
0x1234, -- 参数1：整数值，写入为4字节（大端：00 00 12 34）
0x4567, -- 参数2：整数值，写入为4字节（大端：00 00 45 67）
0x12, -- 参数3：整数值，写入为2字节（大端：00 12）
"abcdefg" -- 参数4：字符串，写入7字节ASCII码（61 62 63 64 65 66 67）
)
 */
#define PACKNUMBER(OP, T)                                    \
    case OP:                                                 \
    {                                                        \
        T a = (T)luaL_checknumber(L, i++);                   \
        doswap(swap, &a, sizeof(a));                         \
        write_len += add_bytes(buff, (void *)&a, sizeof(a)); \
        break;                                               \
    }

#define PACKINT(OP, T)                                    \
    case OP:                                                 \
    {                                                        \
        T a = (T)luaL_checkinteger(L, i++);                   \
        doswap(swap, &a, sizeof(a));                         \
        write_len += add_bytes(buff, (void *)&a, sizeof(a)); \
        break;                                               \
    }

static int l_zbuff_pack(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    int i = 3;
    char *f = (char *)luaL_checkstring(L, 2);
    int swap = 0;
    int write_len = 0; //已写入长度
    while (*f)
    {
        if (buff->cursor == buff->len) //到头了
            break;
        int c = *f++;
        int N = 1;
        if (isdigit(*f))
        {
            N = 0;
            while (isdigit(*f))
                N = 10 * N + (*f++) - '0';
        }
        while (N--)
        {
            if (buff->cursor == buff->len) //到头了
                break;
            switch (c)
            {
            case OP_LITTLEENDIAN:
            case OP_BIGENDIAN:
            case OP_NATIVE:
            {
                swap = doendian(c);
                N = 0;
                break;
            }
            case OP_STRING:
            {
                size_t l;
                const char *a = luaL_checklstring(L, i++, &l);
                write_len += add_bytes(buff, a, l);
                break;
            }
            PACKNUMBER(OP_NUMBER, lua_Number)
            PACKNUMBER(OP_DOUBLE, double)
            PACKNUMBER(OP_FLOAT, float)
            PACKINT(OP_CHAR, char)
            PACKINT(OP_BYTE, unsigned char)
            PACKINT(OP_SHORT, short)
            PACKINT(OP_USHORT, unsigned short)
            PACKINT(OP_INT, int)
            PACKINT(OP_UINT, unsigned int)
            PACKINT(OP_LONG, long)
            PACKINT(OP_ULONG, unsigned long)
            case ' ':
            case ',':
                break;
            default:
                badcode(L, c);
                break;
            }
        }
    }
    lua_pushinteger(L, write_len);
    return 1;
}

#define UNPACKINT(OP, T)                    \
    case OP:                                \
    {                                       \
        T a;                                \
        int m = sizeof(a);                  \
        if (i + m > len)                    \
            goto done;                      \
        memcpy(&a, s + i, m);               \
        i += m;                             \
        doswap(swap, &a, m);                \
        lua_pushinteger(L, (lua_Integer)a); \
        ++n;                                \
        break;                              \
    }

#define UNPACKINT8(OP,T)		\
	case OP:				\
	{					\
		T a;				\
		int m=sizeof(a);			\
		if (i+m>len) goto done;		\
		memcpy(&a,s+i,m);			\
		i+=m;				\
		doswap(swap,&a,m);			\
		int t = (a & 0x80)?(0xffffff00+a):a;\
		lua_pushinteger(L,(lua_Integer)t);	\
		++n;				\
		break;				\
	}

#define UNPACKNUMBER(OP, T)               \
    case OP:                              \
    {                                     \
        T a;                              \
        int m = sizeof(a);                \
        if (i + m > len)                  \
            goto done;                    \
        memcpy(&a, s + i, m);             \
        i += m;                           \
        doswap(swap, &a, m);              \
        lua_pushnumber(L, (lua_Number)a); \
        ++n;                              \
        break;                            \
    }
/**
将一系列数据按照格式字符读取出来（从当前指针位置开始；执行后指针会向后移动）
@api buff:unpack(format)
@string 数据的格式（符号含义见上面pack接口的例子）
@return int 成功读取的数据字节长度
@return any 按格式读出来的数据
@usage
local cnt,a,b,c,s = buff:unpack(">IIHA10") -- 按格式读取几个数据
--如果全部成功读取，cnt就是4+4+2+10=20
 */
static int l_zbuff_unpack(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    char *f = (char *)luaL_checkstring(L, 2);
    size_t len = buff->len - buff->cursor;
    const char *s = (const char*)(buff->addr + buff->cursor);
    int i = 0;
    int n = 0;
    int swap = 0;
    lua_pushnil(L); //给个数占位用的
    while (*f)
    {
        int c = *f++;
        int N = 1;
        if (isdigit(*f))
        {
            N = 0;
            while (isdigit(*f))
                N = 10 * N + (*f++) - '0';
            if (N == 0 && c == OP_STRING)
            {
                lua_pushliteral(L, "");
                ++n;
            }
        }
        while (N--){
            if (!lua_checkstack(L, n))
                return luaL_error(L, "too many results to unpack");
            switch (c)
            {
            case OP_LITTLEENDIAN:
            case OP_BIGENDIAN:
            case OP_NATIVE:
            {
                swap = doendian(c);
                N = 0;
                break;
            }
            case OP_STRING:
            {
                ++N;
                if (i + N > len)
                    goto done;
                lua_pushlstring(L, s + i, N);
                i += N;
                ++n;
                N = 0;
                break;
            }
            UNPACKNUMBER(OP_NUMBER, lua_Number)
            UNPACKNUMBER(OP_DOUBLE, double)
            UNPACKNUMBER(OP_FLOAT, float)
			UNPACKINT8(OP_CHAR, char)
            UNPACKINT(OP_BYTE, unsigned char)
            UNPACKINT(OP_SHORT, short)
            UNPACKINT(OP_USHORT, unsigned short)
            UNPACKINT(OP_INT, int)
            UNPACKINT(OP_UINT, unsigned int)
            UNPACKINT(OP_LONG, long)
            UNPACKINT(OP_ULONG, unsigned long)
            case ' ':
            case ',':
                break;
            default:
                badcode(L, c);
                break;
            }
        }
    }
done:
    buff->cursor += i;
    lua_pushinteger(L, i);
    lua_replace(L, -n - 2);
    return n + 1;
}

/**
读取一个指定类型的数据（从当前指针位置开始；执行后指针会向后移动）
@api buff:read类型()
@注释 读取类型可为：I8、U8、I16、U16、I32、U32、I64、U64、F32、F64
@return number 读取的数据，如果越界则为nil
@usage
local data = buff:readI8()
local data = buff:readU32()
*/
#define zread(n, t, f)                                       \
    static int l_zbuff_read_##n(lua_State *L)                \
    {                                                        \
        luat_zbuff_t *buff = tozbuff(L);                      \
        if (buff->len - buff->cursor < sizeof(t))            \
            return 0;                                        \
        t tmp;                                              \
        memcpy(&tmp, buff->addr + buff->cursor, sizeof(t));  \
        lua_push##f(L, tmp);                                 \
        buff->cursor += sizeof(t);                           \
        return 1;                                            \
    }
zread(i8, int8_t, integer);
zread(u8, uint8_t, integer);
zread(i16, int16_t, integer);
zread(u16, uint16_t, integer);
zread(i32, int32_t, integer);
zread(u32, uint32_t, integer);
zread(i64, int64_t, integer);
zread(u64, uint64_t, integer);
zread(f32, float, number);
zread(f64, double, number);

/**
写入一个指定类型的数据（从当前指针位置开始；执行后指针会向后移动）
@api buff:write类型()
@number 待写入的数据
@注释 写入类型可为：I8、U8、I16、U16、I32、U32、I64、U64、F32、F64
@return number 成功写入的长度
@usage
local len = buff:writeI8(10)
local len = buff:writeU32(1024)
*/
#define zwrite(n, t, f)                                               \
    static int l_zbuff_write_##n(lua_State *L)                        \
    {                                                                 \
        luat_zbuff_t *buff = tozbuff(L);                                \
        if (buff->len - buff->cursor < sizeof(t))                     \
        {                                                             \
            lua_pushinteger(L, 0);                                    \
            return 1;                                                 \
        }                                                             \
        t tmp =   (t)luaL_check##f(L, 2);                             \
        memcpy(buff->addr + buff->cursor, &(tmp), sizeof(t));            \
        buff->cursor += sizeof(t);                                    \
        lua_pushinteger(L, sizeof(t));                                \
        return 1;                                                     \
    }
zwrite(i8, int8_t, integer);
zwrite(u8, uint8_t, integer);
zwrite(i16, int16_t, integer);
zwrite(u16, uint16_t, integer);
zwrite(i32, int32_t, integer);
zwrite(u32, uint32_t, integer);
zwrite(i64, int64_t, integer);
zwrite(u64, uint64_t, integer);
zwrite(f32, float, number);
zwrite(f64, double, number);

/**
按起始位置和长度取出数据（与当前指针位置无关；执行后指针位置不变）
@api buff:toStr(offset,length)
@int 数据的起始位置（起始位置为0）,默认值也是0
@int 数据的长度,默认是全部数据
@return string 读出来的数据
@usage
local s = buff:toStr(0,5)--读取开头的五个字节数据
local s = buff:toStr() -- 取出整个zbuff的数据
local s = buff:toStr(0, buff:used()) -- 取出已使用的部分, 与buff:query()一样
 */
static int l_zbuff_toStr(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    int start = luaL_optinteger(L, 2, 0);
    if (start > buff->len)
        start = buff->len;
    int len = luaL_optinteger(L, 3, buff->len);
    if (start + len > buff->len)
        len = buff->len - start;
    lua_pushlstring(L, (const char*)(buff->addr + start), len);
    return 1;
}

/**
获取zbuff对象的长度（与当前指针位置无关；执行后指针位置不变）
@api buff:len()
@return int zbuff对象的长度
@usage
len = buff:len()
len = #buff
 */
static int l_zbuff_len(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    lua_pushinteger(L, buff->len);
    return 1;
}

/**
设置buff对象的FrameBuffer属性（与当前指针位置无关；执行后指针位置不变）
@api buff:setFrameBuffer(width,height,bit,color)
@int FrameBuffer的宽度
@int FrameBuffer的高度
@int FrameBuffer的色位深度
@int FrameBuffer的初始颜色
@return bool 设置成功会返回true
@usage
result = buff:setFrameBuffer(320,240,16,0xffff)
 */
static int l_zbuff_set_frame_buffer(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    //检查空间够不够
    if((luaL_checkinteger(L, 2) * luaL_checkinteger(L, 3) * luaL_checkinteger(L, 4) - 1) / 8 + 1 > buff->len)
        return 0;
    buff->width = luaL_checkinteger(L,2);
    buff->height = luaL_checkinteger(L,3);
    buff->bit = luaL_checkinteger(L,4);
    if (lua_isinteger(L, 5))
    {
        LUA_INTEGER color = luaL_checkinteger(L, 5);
        uint32_t i;
        for (i = 0; i < buff->width * buff->height; i++)
            set_framebuffer_point(buff, i, color);
    }
    lua_pushboolean(L,1);
    return 1;
}

/**
设置或获取FrameBuffer某个像素点的颜色（与当前指针位置无关；执行后指针位置不变）
@api buff:pixel(x,y,color)
@int 与最左边的距离，范围是0~宽度-1
@int 与最上边的距离，范围是0~高度-1
@int 颜色，如果留空则表示获取该位置的颜色
@return any 设置颜色时，设置成功会返回true；读取颜色时，返回颜色的值，读取失败返回nil
@usage
rerult = buff:pixel(0,3,0)
color = buff:pixel(0,3)
 */
static int l_zbuff_pixel(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    uint32_t x = luaL_checkinteger(L,2);
    uint32_t y = luaL_checkinteger(L,3);
    if(x>=buff->width||y>=buff->height)
        return 0;
    if (lua_isinteger(L, 4))
    {
        LUA_INTEGER color = luaL_checkinteger(L, 4);
        set_framebuffer_point(buff, x + y * buff->width, color);
        lua_pushboolean(L,1);
        return 1;
    }
    else
    {
        lua_pushinteger(L,get_framebuffer_point(buff,x + y * buff->width));
        return 1;
    }
}

/**
画一条线（与当前指针位置无关；执行后指针位置不变）
@api buff:drawLine(x1,y1,x2,y2,color)
@int 起始坐标点与最左边的距离，范围是0~宽度-1
@int 起始坐标点与最上边的距离，范围是0~高度-1
@int 结束坐标点与最左边的距离，范围是0~宽度-1
@int 结束坐标点与最上边的距离，范围是0~高度-1
@int 可选，颜色，默认为0
@return bool 画成功会返回true
@usage
rerult = buff:drawLine(0,0,2,3,0xffff)
 */
#define abs(n) (n>0?n:-n)
static int l_zbuff_draw_line(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    if(buff->width<=0) return 0;//不是framebuffer数据
    uint32_t x0 = luaL_checkinteger(L,2);
    uint32_t y0 = luaL_checkinteger(L,3);
    uint32_t x1 = luaL_checkinteger(L,4);
    uint32_t y1 = luaL_checkinteger(L,5);
    uint32_t color = luaL_optinteger(L,6,0);

    //代码参考https://blog.csdn.net/qq_43405938/article/details/102700922
    int x = x0, y = y0, dx = x1 - x0, dy = y1 - y0;
    int max = (abs(dy) > abs(dx)) ? abs(dy) : abs(dx);
    int min = (abs(dy) > abs(dx)) ? abs(dx) : abs(dy);
    float e = 2 * min - max;
    for (int i = 0; i < max; i++)
    {
        if(x>=0&&y>=0&&x<buff->width&&y<buff->height)
            set_framebuffer_point(buff,x+y*buff->width,color);
        if (e >= 0)
        {
            e = e - 2 * max;
            (abs(dy) > abs(dx)) ? (dx >= 0 ? x++ : x--) : (dy >= 0 ? y++ : y--);
        }
        e += 2 * min;
        (abs(dy) > abs(dx)) ? (dy >= 0 ? y++ : y--) : (dx >= 0 ? x++ : x--);
    }

    lua_pushboolean(L,1);
    return 1;
}

/**
画一个矩形（与当前指针位置无关；执行后指针位置不变）
@api buff:drawRect(x1,y1,x2,y2,color,fill)
@int 起始坐标点与最左边的距离，范围是0~宽度-1
@int 起始坐标点与最上边的距离，范围是0~高度-1
@int 结束坐标点与最左边的距离，范围是0~宽度-1
@int 结束坐标点与最上边的距离，范围是0~高度-1
@int 可选，颜色，默认为0
@bool 可选，是否在内部填充，默认nil
@return bool 画成功会返回true
@usage
rerult = buff:drawRect(0,0,2,3,0xffff)
 */
#define CHECK0(n,max) if(n<0)n=0;if(n>=max)n=max-1
static int l_zbuff_draw_rectangle(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    if(buff->width<=0) return 0;//不是framebuffer数据
    int32_t x1 = (int32_t)luaL_checkinteger(L,2);  CHECK0(x1,buff->width);
    int32_t y1 = (int32_t)luaL_checkinteger(L,3);  CHECK0(y1,buff->height);
    int32_t x2 = (int32_t)luaL_checkinteger(L,4);  CHECK0(x2,buff->width);
    int32_t y2 = (int32_t)luaL_checkinteger(L,5);  CHECK0(y2,buff->height);
    int32_t color = (int32_t)luaL_optinteger(L,6,0);
    uint8_t fill = lua_toboolean(L,7);
    int x,y;
    int32_t xmax=x1>x2?x1:x2,xmin=x1>x2?x2:x1,ymax=y1>y2?y1:y2,ymin=y1>y2?y2:y1;
    if(fill){
        for(x=xmin;x<=xmax;x++)
            for(y=ymin;y<=ymax;y++)
                set_framebuffer_point(buff,x+y*buff->width,color);
    }else{
        for(x=xmin;x<=xmax;x++){
            set_framebuffer_point(buff,x+ymin*buff->width,color);
            set_framebuffer_point(buff,x+ymax*buff->width,color);
        }
        for(y=ymin;y<=ymax;y++){
            set_framebuffer_point(buff,xmin+y*buff->width,color);
            set_framebuffer_point(buff,xmax+y*buff->width,color);
        }
    }
    lua_pushboolean(L,1);
    return 1;
}

/**
画一个圆形（与当前指针位置无关；执行后指针位置不变）
@api buff:drawCircle(x,y,r,color,fill)
@int **圆心**与最左边的距离，范围是0~宽度-1
@int **圆心**与最上边的距离，范围是0~高度-1
@int 圆的半径
@int 可选，圆的颜色，默认为0
@bool 可选，是否在内部填充，默认nil
@return bool 画成功会返回true
@usage
rerult = buff:drawCircle(15,5,3,0xC)
rerult = buff:drawCircle(15,5,3,0xC,true)
 */
#define DRAW_CIRCLE_ALL(buff, xc, yc, x, y, c)                                \
    {                                                                          \
        if (x >= 0 && y >= 0 && x < buff->width && y < buff->height)           \
            set_framebuffer_point(buff, (xc + x) + (yc + y) * buff->width, c); \
        if (x >= 0 && y >= 0 && x < buff->width && y < buff->height)           \
            set_framebuffer_point(buff, (xc - x) + (yc + y) * buff->width, c); \
        if (x >= 0 && y >= 0 && x < buff->width && y < buff->height)           \
            set_framebuffer_point(buff, (xc + x) + (yc - y) * buff->width, c); \
        if (x >= 0 && y >= 0 && x < buff->width && y < buff->height)           \
            set_framebuffer_point(buff, (xc - x) + (yc - y) * buff->width, c); \
        if (x >= 0 && y >= 0 && x < buff->width && y < buff->height)           \
            set_framebuffer_point(buff, (xc + y) + (yc + x) * buff->width, c); \
        if (x >= 0 && y >= 0 && x < buff->width && y < buff->height)           \
            set_framebuffer_point(buff, (xc - y) + (yc + x) * buff->width, c); \
        if (x >= 0 && y >= 0 && x < buff->width && y < buff->height)           \
            set_framebuffer_point(buff, (xc + y) + (yc - x) * buff->width, c); \
        if (x >= 0 && y >= 0 && x < buff->width && y < buff->height)           \
            set_framebuffer_point(buff, (xc - y) + (yc - x) * buff->width, c); \
    }
static int l_zbuff_draw_circle(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    if(buff->width<=0) return 0;//不是framebuffer数据
    int32_t xc = luaL_checkinteger(L,2);
    int32_t yc = luaL_checkinteger(L,3);
    int32_t r = luaL_checkinteger(L,4);
    int32_t color = luaL_optinteger(L,5,0);
    uint8_t fill = lua_toboolean(L,6);

    //代码参考https://www.cnblogs.com/wlzy/p/8695226.html
    //圆不在可见区域
    if (xc + r < 0 || xc - r >= buff->width || yc + r < 0 || yc - r >= buff->height)
        return 0;

    int x = 0, y = r, yi, d;
    d = 3 - 2 * r;

    while (x <= y)
    {
        if (fill)
        {
            for (yi = x; yi <= y; yi++)
                DRAW_CIRCLE_ALL(buff, xc, yc, x, yi, color);
        }
        else
        {
            DRAW_CIRCLE_ALL(buff, xc, yc, x, y, color);
        }
        if (d < 0)
        {
            d = d + 4 * x + 6;
        }
        else
        {
            d = d + 4 * (x - y) + 10;
            y--;
        }
        x++;
    }
    lua_pushboolean(L,1);
    return 1;
}

/**
以下标形式进行数据读写（与当前指针位置无关；执行后指针位置不变）
@api buff[n]
@int 第几个数据，以0开始的下标（C标准）
@return number 该位置的数据
@usage
buff[0] = 0xc8
local data = buff[0]
 */
static int l_zbuff_index(lua_State *L)
{
    //luat_zbuff_t **pp = luaL_checkudata(L, 1, LUAT_ZBUFF_TYPE);
    // int i;

    luaL_getmetatable(L, LUAT_ZBUFF_TYPE);
    lua_pushvalue(L, 2);
    lua_rawget(L, -2);

    if (lua_isnil(L, -1))
    {
        /* found no method, so get value from userdata. */
        luat_zbuff_t *buff = tozbuff(L);
        int o = luaL_checkinteger(L, 2);
        if (o >= buff->len)
            return 0;
        lua_pushinteger(L, buff->addr[o]);
        return 1;
    };
    return 1;
}

static int l_zbuff_newindex(lua_State *L)
{
    if (lua_isinteger(L, 2))
    {
        luat_zbuff_t *buff = tozbuff(L);
        if (lua_isinteger(L, 2))
        {
            int o = luaL_checkinteger(L, 2);
            int n = luaL_checkinteger(L, 3) % 256;
            if (o > buff->len)
                return 0;
            buff->addr[o] = n;
        }
    }
    return 0;
}

// __gc l_zbuff_gc为zbuff默认gc函数，gc调用时会释放申请内存并gc掉zbuff，下面为用户手动调用注释

/**
释放zbuff所申请内存 注意：gc时会自动释放zbuff以及zbuff所申请内存，所以通常无需调用此函数，调用前请确认您已清楚此函数用处！调用此函数并不会释放掉zbuff，仅会释放掉zbuff所申请的内存，zbuff需等gc时自动释放！！！
@api buff:free()
@usage
buff:free()
 */
static int l_zbuff_gc(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    if (buff->addr){
        luat_heap_opt_free(buff->type,buff->addr);
        buff->addr = NULL;
        buff->len = 0;
        buff->used = 0;
    }
    return 0;
}

int __zbuff_resize(luat_zbuff_t *buff, uint32_t new_size)
{
	void *p = luat_heap_opt_realloc(buff->type, buff->addr, new_size?new_size:1);
	if (p)
	{
		buff->addr = p;
		buff->len = new_size;
		buff->used = (buff->len > buff->used)?buff->used:buff->len;
		return 0;
	}
	else
	{
        LLOGE("zbuff realloc failed %d -> %d", buff->len, new_size);
		return -1;
	}
}

/**
调整zbuff实际分配空间的大小，类似于realloc的效果，new = realloc(old, n)，可以扩大或者缩小（如果缩小后len小于了used，那么used=新len）
@api buff:resize(n)
@int 新空间大小
@usage
buff:resize(20)
 */
static int l_zbuff_resize(lua_State *L)
{
	luat_zbuff_t *buff = tozbuff(L);
	if (lua_isinteger(L, 2))
	{
		uint32_t n = luaL_checkinteger(L, 2);
		__zbuff_resize(buff, n);
	}
	return 0;
}

/**
zbuff动态写数据，类似于memcpy效果，当原有空间不足时动态扩大空间
@api buff:copy(start, para,...)
@int 写入buff的起始位置，如果不为数字，则为buff的used，如果小于0，则从used往前数，-1 = used - 1
@any 写入buff的数据，string或zbuff者时为一个参数，number时可为多个参数
@return number 数据成功写入的长度
@usage
local len = buff:copy(nil, "123") -- 类似于memcpy(&buff[used], "123", 3) used+= 3 从buff开始写入数据,指针相应地往后移动
local len = buff:copy(0, "123") -- 类似于memcpy(&buff[0], "123", 3) if (used < 3) used = 3 从位置0写入数据,指针有可能会移动
local len = buff:copy(2, 0x1a,0x30,0x31,0x32,0x00,0x01)  -- 类似于memcpy(&buff[2], [0x1a,0x30,0x31,0x32,0x00,0x01], 6) if (used < (2+6)) used = (2+6)从位置2开始，按数值写入多个字节数据
local len = buff:copy(9, buff2)  -- 类似于memcpy(&buff[9], &buff2[0], buff2的used) if (used < (9+buff2的used)) used = (9+buff2的used) 从位置9开始，合并入buff2里0~used的内容
local len = buff:copy(5, buff2, 10, 1024)  -- 类似于memcpy(&buff[5], &buff2[10], 1024) if (used < (5+1024)) used = (5+1024)
 */
static int l_zbuff_copy(lua_State *L)
{
	luat_zbuff_t *buff = tozbuff(L);
	int temp_cursor = luaL_optinteger(L, 2, buff->used);
	if (temp_cursor < 0)
	{
		temp_cursor = buff->used + temp_cursor;
		if (temp_cursor < 0)
		{
			lua_pushinteger(L, 0);
			return 1;
		}
	}
    if (lua_isinteger(L, 3))
    {
        int len = 0;
        int data = 0;
        while (lua_isinteger(L, 3 + len))
        {
        	if (temp_cursor > buff->len)
        	{
        		if (__zbuff_resize(buff, temp_cursor * 2))
        		{
        	        lua_pushinteger(L, len);
        	        return 1;
        		}
        	}
            data = luaL_checkinteger(L, 3 + len);
            *(uint8_t *)(buff->addr + temp_cursor) = data % 0x100;
            temp_cursor++;
            len++;
        }
        buff->used = (temp_cursor > buff->used)?temp_cursor:buff->used;
        lua_pushinteger(L, len);
        return 1;
    }
    else if (lua_isstring(L, 3))
    {
        size_t len;
        const char *data = luaL_checklstring(L, 3, &len);
        if (len + temp_cursor > buff->len) //防止越界
        {
        	if (__zbuff_resize(buff, buff->len + len + temp_cursor))
        	{
    	        lua_pushinteger(L, 0);
    	        return 1;
        	}
        }
        memcpy(buff->addr + temp_cursor, data, len);
        temp_cursor = temp_cursor + len;
        buff->used = (temp_cursor > buff->used)?temp_cursor:buff->used;
        lua_pushinteger(L, len);
        return 1;
    }
    else if (lua_isuserdata(L, 3))
    {
        luat_zbuff_t *copy_buff = ((luat_zbuff_t *)luaL_checkudata(L, 3, LUAT_ZBUFF_TYPE));
        uint32_t start =  luaL_optinteger(L, 4, 0);
        uint32_t len =  luaL_optinteger(L, 5, copy_buff->used);
        if (len + temp_cursor > buff->len) //防止越界
        {
        	if (__zbuff_resize(buff, buff->len + len + temp_cursor))
        	{
    	        lua_pushinteger(L, 0);
    	        return 1;
        	}
        }
        memcpy(buff->addr + temp_cursor, copy_buff->addr + start, len);
        temp_cursor += len;
        buff->used = (temp_cursor > buff->used)?temp_cursor:buff->used;
        lua_pushinteger(L, len);
        return 1;
    }
    lua_pushinteger(L, 0);
    return 1;
}

/**
设置/获取zbuff里最后一个数据位置指针到首地址的偏移量，来表示zbuff内已有有效数据量大小，注意这个不同于分配的空间大小，由于seek()会改变最后一个数据位置指针，因此也会影响到used()返回值。
@api buff:used()
@int 最后一个数据位置指针到首地址的偏移量，不能是负数，如果不填则不更改当前值，如果该值超过了buff总量，则自动改为buff总量
@return int 有效数据量大小
@usage
buff:used()	--直接返回当前的有效数据量大小
buff:used(123) --设置当前的有效数据量为123字节，如果buff本身不到123字节，比如120字节，则会改成120，返回值是120
*/
static int l_zbuff_used(lua_State *L)
{
	luat_zbuff_t *buff = tozbuff(L);
	if (lua_isinteger(L, 2))
	{
		size_t temp_cursor = luaL_optinteger(L, 2, buff->used);
		if (temp_cursor > buff->len)
		{
			buff->used = buff->len;
		}
		else
		{
			buff->used = temp_cursor;
		}
	}
    lua_pushinteger(L, buff->used);
    return 1;
}

/**
删除zbuff 0~used范围内的一段数据，注意只是改变了used的值，并不是真的在ram里去清除掉数据
@api buff:del(offset,length)
@int 起始位置start, 默认0，如果<0则从used往前数，比如 -1 那么start= used - 1
@int 长度del_len，默认为used，如果start + del_len数值大于used，会强制调整del_len = used - start
@usage
buff:del(1,4)	--从位置1开始删除4个字节数据
buff:del(-1,4)	--从位置used-1开始删除4个字节数据，但是这肯定会超过used，所以del_len会调整为1，实际上就是删掉了最后一个字节
*/
static int l_zbuff_del(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    int start = luaL_optinteger(L, 2, 0);
    if (start < 0)
    {
    	start += buff->used;
    	if (start < 0)
    	{
    		return 0;
    	}
    }

    if (start >= (int)buff->used)
        return 0;

    uint32_t len = luaL_optinteger(L, 3, buff->used);
    if (start + len > buff->used)
        len = buff->used - start;
    if (!len)
    {
    	return 0;
    }
    if ((start + len) == buff->used)
    {
    	buff->used = start;
    }
    else
    {
		uint32_t rest = buff->used - len;
		memmove(buff->addr + start, buff->addr + start + len, rest);
		buff->used = rest;
    }

    return 0;
}

static uint32_t BytesGetBe32(const void *ptr)
{
    const uint8_t *p = (const uint8_t *)ptr;
    return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
}

static uint32_t BytesGetLe32(const void *ptr)
{
    const uint8_t *p = (const uint8_t *)ptr;
    return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
}

/**
按起始位置和长度0~used范围内取出数据，如果是1,2,4,8字节，且填写了isbigend参数，则根据isbigend,issigned,isfloat转换成浮点或者整形
@api buff:query(offset,length,isbigend,issigned,isfloat)
@int 数据的起始位置（起始位置为0）
@int 数据的长度
@boolean 是否是大端格式，如果为nil，则不会转换，直接字节流输出，false为小端格式，true为大端格式
@boolean 是否是有符号的，默认为false
@boolean 是否是浮点型，默认为false
@return string 读出来的数据，如果取出数据是1,2,4,8字节，且isbigend填写了true或者false，则输出浮点或者整形
@usage
local s = buff:query(0,5)--读取开头的五个字节数据
 */
static int l_zbuff_query(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    int start = luaL_optinteger(L, 2, 0);
    if (start < 0)
    {
    	start += buff->used;
    	if (start < 0)
    	{
    		lua_pushnil(L);
    		return 1;
    	}
    }
    if (start > buff->used)
        start = buff->used;
    uint32_t len = luaL_optinteger(L, 3, buff->used);
    if (start + len > buff->used)
        len = buff->used - start;
    if (!len)
    {
		lua_pushnil(L);
		return 1;
    }
    if (lua_isboolean(L, 4) && (len <= 8))
    {
    	int is_bigend = lua_toboolean(L, 4);
    	int is_float = 0;
    	int is_signed = 0;
    	if (lua_isboolean(L, 5))
    	{
    		is_signed = lua_toboolean(L, 5);
    	}
    	if (lua_isboolean(L, 6))
    	{
    		is_float = lua_toboolean(L, 6);
    	}
    	uint8_t *p = buff->addr + start;
    	uint8_t uc;
    	int16_t s;
    	uint16_t us;
    	int32_t i;
    	// uint32_t ui;
    	int64_t l;
    	float f;
    	double d;
    	switch(len)
    	{
    	case 1:
    		if (is_signed)
    		{
    			i = (p[0] & 0x80)?(p[0] + 0xffffff00):p[0];
    			lua_pushinteger(L, i);
    		}
    		else
    		{
    			uc = p[0];
    			lua_pushinteger(L, uc);
    		}
    		break;
    	case 2:
    		if (is_bigend)
    		{
    			us = (p[0] << 8) | p[1];
    		}
    		else
    		{
    			us = (p[1] << 8) | p[0];
    		}
    		if (is_signed)
    		{
    			s = us;
    			lua_pushinteger(L, s);
    		}
    		else
    		{
    			lua_pushinteger(L, us);
    		}
    		break;
    	case 4:
    		if (is_float)
    		{
    			memcpy(&f, p, len);
    			lua_pushnumber(L, f);
    		}
    		else
    		{
        		if (is_bigend)
        		{
        			i = BytesGetBe32(p);
        		}
        		else
        		{
        			i = BytesGetLe32(p);
        		}
        		lua_pushinteger(L, i);
    		}

    		break;
    	case 8:
    		if (is_float)
    		{
    			memcpy(&d, p, len);
    			lua_pushnumber(L, d);
    		}
    		else
    		{
        		if (is_bigend)
        		{
        			l = BytesGetBe32(p + 4) | ((int64_t)BytesGetBe32(p) << 32);
        		}
        		else
        		{
        			l = BytesGetLe32(p) | ((int64_t)BytesGetLe32(p + 4) << 32);
        		}
        		lua_pushinteger(L, l);
    		}
    		break;
    	default:
    		lua_pushlstring(L, (const char*)(buff->addr + start), len);
    		break;
    	}
    	return 1;
    }
    lua_pushlstring(L, (const char*)(buff->addr + start), len);
    return 1;
}

/**
zbuff的类似于memset操作，类似于memset(&buff[start], num, len)，当然有ram越界保护，会对len有一定的限制
@api buff:set(start, num, len)
@int 可选，开始位置，默认为0,
@int 可选，默认为0。要设置为的值
@int 可选，长度，默认为全部空间，如果超出范围了，会自动截断
@usage
-- 全部初始化为0
buff:set() --等同于 memset(buff, 0, sizeof(buff))
buff:set(8) --等同于 memset(&buff[8], 0, sizeof(buff) - 8)
buff:set(0, 0x55) --等同于 memset(buff, 0x55, sizeof(buff))
buff:set(4, 0xaa, 12) --等用于 memset(&buff[4], 0xaa, 12)
 */
static int l_zbuff_set(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    int num = luaL_optinteger(L, 3, 0);
    uint32_t start = luaL_optinteger(L, 2, 0);
    uint32_t len = luaL_optinteger(L, 4, buff->len);
    memset(buff->addr + start, num & 0x00ff, ((len + start) > buff->len)?(buff->len - start):len);
    return 0;
}

/**
zbuff的类似于memcmp操作，类似于memcmp(&buff[start], &buff2[start2], len)
@api buff:isEqual(start, buff2, start2, len)
@int 可选，开始位置，默认为0,
@zbuff 比较的对象
@int 可选，比较的对象的开始位置，默认为0
@int 比较长度
@return boolean true相等，false不相等
@return int 相等返回0，不相等返回第一个不相等位置的序号
@usage
local result, offset = buff:isEqual(1, buff2, 2, 10) --等同于memcmp(&buff[1], &buff2[2], 10)
 */
static int l_zbuff_equal(lua_State *L)
{
    luat_zbuff_t *buff = tozbuff(L);
    uint32_t offset1 = luaL_optinteger(L, 2, 0);
    luat_zbuff_t *buff2 = ((luat_zbuff_t *)luaL_checkudata(L, 3, LUAT_ZBUFF_TYPE));
    uint32_t offset2 = luaL_optinteger(L, 4, 0);
    uint32_t len = luaL_optinteger(L, 5, 1);
    uint32_t i;
    uint8_t *b1 = buff->addr + offset1;
    uint8_t *b2 = buff2->addr + offset2;
    for(i = 0; i < len; i++) {
    	if (b1[i] != b2[i]) {
    		lua_pushboolean(L, 0);
    		lua_pushinteger(L, i);
    		return 2;
    	}
    }
	lua_pushboolean(L, 1);
	lua_pushinteger(L, 0);
	return 2;
}

/**
将当前zbuff数据转base64,输出到下一个zbuff中
@api buff:toBase64(dst)
@userdata zbuff指针
@return int 转换后的实际长度
@usage
-- dst:len必须大于buff:used() * 1.35 + 3, 确保有足够空间存放base64数据
buff:toBase64(dst)
*/
#include "luat_str.h"
static int l_zbuff_to_base64(lua_State *L) {
    luat_zbuff_t *buff = ((luat_zbuff_t *)luaL_checkudata(L, 1, LUAT_ZBUFF_TYPE));
    luat_zbuff_t *buff2 = ((luat_zbuff_t *)luaL_checkudata(L, 2, LUAT_ZBUFF_TYPE));
    size_t olen = 0;
    int ret = luat_str_base64_encode(buff2->addr, buff2->len, &olen, buff->addr, buff->used);
    if (ret) {
        LLOGE("zbuff toBase64 failed %d", ret);
        lua_pushinteger(L, 0);
    }
    else {
        buff2->used = olen;
        lua_pushinteger(L, olen);
    }
    return 1;
};

static const luaL_Reg lib_zbuff[] = {
    {"write", l_zbuff_write},
    {"read", l_zbuff_read},
    {"clear", l_zbuff_clear},
    {"seek", l_zbuff_seek},
    {"pack", l_zbuff_pack},
    {"unpack", l_zbuff_unpack},
    {"get", l_zbuff_index},
    {"readI8", l_zbuff_read_i8},
    {"readI16", l_zbuff_read_i16},
    {"readI32", l_zbuff_read_i32},
    {"readI64", l_zbuff_read_i64},
    {"readU8", l_zbuff_read_u8},
    {"readU16", l_zbuff_read_u16},
    {"readU32", l_zbuff_read_u32},
    {"readU64", l_zbuff_read_u64},
    {"readF32", l_zbuff_read_f32},
    {"readF64", l_zbuff_read_f64},
    {"writeI8", l_zbuff_write_i8},
    {"writeI16", l_zbuff_write_i16},
    {"writeI32", l_zbuff_write_i32},
    {"writeI64", l_zbuff_write_i64},
    {"writeU8", l_zbuff_write_u8},
    {"writeU16", l_zbuff_write_u16},
    {"writeU32", l_zbuff_write_u32},
    {"writeU64", l_zbuff_write_u64},
    {"writeF32", l_zbuff_write_f32},
    {"writeF64", l_zbuff_write_f64},
    {"toStr", l_zbuff_toStr},
    {"len", l_zbuff_len},
    {"setFrameBuffer", l_zbuff_set_frame_buffer},
    {"pixel", l_zbuff_pixel},
    {"drawLine", l_zbuff_draw_line},
    {"drawRect", l_zbuff_draw_rectangle},
    {"drawCircle", l_zbuff_draw_circle},
    //{"__index", l_zbuff_index},
    //{"__len", l_zbuff_len},
    //{"__newindex", l_zbuff_newindex},
    {"free", l_zbuff_gc},
	//以下为扩展用法，数据的增减操作尽量不要和上面的read,write一起使用，对数值指针的用法不一致
	{"copy", l_zbuff_copy},
	{"set", l_zbuff_set},
	{"query",l_zbuff_query},
	{"del", l_zbuff_del},
	{"resize", l_zbuff_resize},
	{"reSize", l_zbuff_resize},
	{"used", l_zbuff_used},
	{"isEqual", l_zbuff_equal},
    {"toBase64", l_zbuff_to_base64},
    {NULL, NULL}};

static int luat_zbuff_meta_index(lua_State *L) {
    if (lua_isinteger(L, 2)) {
        return l_zbuff_index(L);
    }
    if (lua_isstring(L, 2)) {
        const char* keyname = luaL_checkstring(L, 2);
        //printf("zbuff keyname = %s\n", keyname);
        int i = 0;
        while (1) {
            if (lib_zbuff[i].name == NULL) break;
            if (!strcmp(keyname, lib_zbuff[i].name)) {
                lua_pushcfunction(L, lib_zbuff[i].func);
                return 1;
            }
            i++;
        }
    }
    return 0;
}

static void createmeta(lua_State *L)
{
    luaL_newmetatable(L, LUAT_ZBUFF_TYPE); /* create metatable for file handles */
    // lua_pushvalue(L, -1);                  /* push metatable */
    // lua_setfield(L, -2, "__index");        /* metatable.__index = metatable */
    // luaL_setfuncs(L, lib_zbuff, 0);        /* add file methods to new metatable */
    //luaL_setfuncs(L, lib_zbuff_metamethods, 0);
    //luaL_setfuncs(L, lib_zbuff, 0);

    lua_pushcfunction(L, l_zbuff_len);
    lua_setfield(L, -2, "__len");
    lua_pushcfunction(L, l_zbuff_gc);
    lua_setfield(L, -2, "__gc");
    lua_pushcfunction(L, luat_zbuff_meta_index);
    lua_setfield(L, -2, "__index");
    lua_pushcfunction(L, l_zbuff_newindex);
    lua_setfield(L, -2, "__newindex");

    lua_pop(L, 1); /* pop new metatable */
    //luaL_newlib(L, lib_zbuff);
}

#include "rotable2.h"
static const rotable_Reg_t reg_zbuff[] =
    {
        {"create",  ROREG_FUNC(l_zbuff_create)},
        //@const SEEK_SET number 以头为基点
        {"SEEK_SET", ROREG_INT(ZBUFF_SEEK_SET)},
        //@const SEEK_CUR number 以当前位置为基点
        {"SEEK_CUR", ROREG_INT(ZBUFF_SEEK_CUR)},
        //@const SEEK_END number 以末尾为基点
        {"SEEK_END", ROREG_INT(ZBUFF_SEEK_END)},
        //@const HEAP_AUTO number 自动申请(如存在psram则在psram进行申请,如不存在或失败则在sram进行申请)
        {"HEAP_AUTO",   ROREG_INT(LUAT_HEAP_AUTO)},
        //@const HEAP_SRAM number 在sram申请
        {"HEAP_SRAM",   ROREG_INT(LUAT_HEAP_SRAM)},
        //@const HEAP_PSRAM number 在psram申请
        {"HEAP_PSRAM",  ROREG_INT(LUAT_HEAP_PSRAM)},
        {NULL,       ROREG_INT(0)
    }
};

LUAMOD_API int luaopen_zbuff(lua_State *L)
{
    luat_newlib2(L, reg_zbuff);
    createmeta(L);
    return 1;
}