mirror of https://github.com/koreader/koreader
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
250 lines
6.8 KiB
C
250 lines
6.8 KiB
C
/*
|
|
KindlePDFViewer: eink framebuffer access
|
|
Copyright (C) 2011 Hans-Werner Hilse <hilse@web.de>
|
|
|
|
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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <string.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mman.h>
|
|
#include <fcntl.h>
|
|
//#include <stdio.h>
|
|
#include "blitbuffer.h"
|
|
|
|
#include "einkfb.h"
|
|
|
|
static int openFrameBuffer(lua_State *L) {
|
|
const char *fb_device = luaL_checkstring(L, 1);
|
|
FBInfo *fb = (FBInfo*) lua_newuserdata(L, sizeof(FBInfo));
|
|
|
|
luaL_getmetatable(L, "einkfb");
|
|
lua_setmetatable(L, -2);
|
|
|
|
#ifndef EMULATE_READER
|
|
/* open framebuffer */
|
|
fb->fd = open(fb_device, O_RDWR);
|
|
if (fb->fd == -1) {
|
|
return luaL_error(L, "cannot open framebuffer %s",
|
|
fb_device);
|
|
}
|
|
|
|
/* initialize data structures */
|
|
memset(&fb->finfo, 0, sizeof(fb->finfo));
|
|
memset(&fb->vinfo, 0, sizeof(fb->vinfo));
|
|
|
|
/* Get fixed screen information */
|
|
if (ioctl(fb->fd, FBIOGET_FSCREENINFO, &fb->finfo)) {
|
|
return luaL_error(L, "cannot get screen info");
|
|
}
|
|
|
|
if (fb->finfo.type != FB_TYPE_PACKED_PIXELS) {
|
|
return luaL_error(L, "video type %x not supported",
|
|
fb->finfo.type);
|
|
}
|
|
|
|
if (ioctl(fb->fd, FBIOGET_VSCREENINFO, &fb->vinfo)) {
|
|
return luaL_error(L, "cannot get variable screen info");
|
|
}
|
|
|
|
if (!fb->vinfo.grayscale) {
|
|
return luaL_error(L, "only grayscale is supported but framebuffer says it isn't");
|
|
}
|
|
|
|
if (fb->vinfo.bits_per_pixel != 4) {
|
|
return luaL_error(L, "only 4bpp is supported for now, got %d bpp",
|
|
fb->vinfo.bits_per_pixel);
|
|
}
|
|
|
|
if (fb->vinfo.xres <= 0 || fb->vinfo.yres <= 0) {
|
|
return luaL_error(L, "invalid resolution %dx%d.\n",
|
|
fb->vinfo.xres, fb->vinfo.yres);
|
|
}
|
|
|
|
/* mmap the framebuffer */
|
|
fb->data = mmap(0, fb->finfo.smem_len,
|
|
PROT_READ | PROT_WRITE, MAP_SHARED, fb->fd, 0);
|
|
if(fb->data == MAP_FAILED) {
|
|
return luaL_error(L, "cannot mmap framebuffer");
|
|
}
|
|
#else
|
|
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
|
|
return luaL_error(L, "cannot initialize SDL.");
|
|
}
|
|
if(!(fb->screen = SDL_SetVideoMode(EMULATE_READER_W, EMULATE_READER_H, 32, SDL_HWSURFACE))) {
|
|
return luaL_error(L, "can't get video surface %dx%d for 32bpp.",
|
|
EMULATE_READER_W, EMULATE_READER_H);
|
|
}
|
|
memset(&fb->finfo, 0, sizeof(fb->finfo));
|
|
memset(&fb->vinfo, 0, sizeof(fb->vinfo));
|
|
fb->vinfo.xres = EMULATE_READER_W;
|
|
fb->vinfo.yres = EMULATE_READER_H;
|
|
fb->vinfo.grayscale = 1;
|
|
fb->vinfo.bits_per_pixel = 4;
|
|
fb->finfo.smem_len = EMULATE_READER_W * EMULATE_READER_H / 2;
|
|
fb->finfo.line_length = EMULATE_READER_W / 2;
|
|
fb->finfo.type = FB_TYPE_PACKED_PIXELS;
|
|
fb->data = malloc(fb->finfo.smem_len);
|
|
#endif
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int getSize(lua_State *L) {
|
|
FBInfo *fb = (FBInfo*) luaL_checkudata(L, 1, "einkfb");
|
|
lua_pushinteger(L, fb->vinfo.xres);
|
|
lua_pushinteger(L, fb->vinfo.yres);
|
|
return 2;
|
|
}
|
|
|
|
static int closeFrameBuffer(lua_State *L) {
|
|
FBInfo *fb = (FBInfo*) luaL_checkudata(L, 1, "einkfb");
|
|
#ifndef EMULATE_READER
|
|
munmap(fb->data, fb->finfo.smem_len);
|
|
close(fb->fd);
|
|
#else
|
|
free(fb->data);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static int blitFullToFrameBuffer(lua_State *L) {
|
|
FBInfo *fb = (FBInfo*) luaL_checkudata(L, 1, "einkfb");
|
|
BlitBuffer *bb = (BlitBuffer*) luaL_checkudata(L, 2, "blitbuffer");
|
|
|
|
if(bb->w != fb->vinfo.xres || bb->h != fb->vinfo.yres) {
|
|
return luaL_error(L, "blitbuffer size must be framebuffer size!");
|
|
}
|
|
|
|
memcpy(fb->data, bb->data, bb->w * bb->h / 2);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int blitToFrameBuffer(lua_State *L) {
|
|
FBInfo *fb = (FBInfo*) luaL_checkudata(L, 1, "einkfb");
|
|
BlitBuffer *bb = (BlitBuffer*) luaL_checkudata(L, 2, "blitbuffer");
|
|
int xdest = luaL_checkint(L, 3) & 0x7FFFFFFE;
|
|
int ydest = luaL_checkint(L, 4);
|
|
int xoffs = luaL_checkint(L, 5) & 0x7FFFFFFE;
|
|
int yoffs = luaL_checkint(L, 6);
|
|
int w = luaL_checkint(L, 7);
|
|
int h = luaL_checkint(L, 8);
|
|
int x, y;
|
|
|
|
// check bounds
|
|
if(yoffs >= bb->h) {
|
|
return 0;
|
|
} else if(yoffs + h > bb->w) {
|
|
h = bb->h - yoffs;
|
|
}
|
|
if(ydest >= fb->vinfo.yres) {
|
|
return 0;
|
|
} else if(ydest + h > fb->vinfo.yres) {
|
|
h = fb->vinfo.yres - ydest;
|
|
}
|
|
if(xoffs >= bb->w) {
|
|
return 0;
|
|
} else if(xoffs + w > bb->w) {
|
|
w = bb->w - xoffs;
|
|
}
|
|
if(xdest >= fb->vinfo.xres) {
|
|
return 0;
|
|
} else if(xdest + w > fb->vinfo.xres) {
|
|
w = fb->vinfo.xres - xdest;
|
|
}
|
|
|
|
w = (w+1) / 2; // we'll always do two pixels at once for now
|
|
|
|
uint8_t *fbptr = (uint8_t*)(fb->data +
|
|
ydest * fb->finfo.line_length +
|
|
xdest / 2);
|
|
uint8_t *bbptr = (uint8_t*)(bb->data +
|
|
yoffs * bb->w / 2 +
|
|
xoffs / 2 );
|
|
|
|
for(y = 0; y < h; y++) {
|
|
memcpy(fbptr, bbptr, w);
|
|
fbptr += fb->finfo.line_length;
|
|
bbptr += (bb->w / 2);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int einkUpdate(lua_State *L) {
|
|
FBInfo *fb = (FBInfo*) luaL_checkudata(L, 1, "einkfb");
|
|
// for Kindle e-ink display
|
|
int fxtype = luaL_optint(L, 2, 0);
|
|
#ifndef EMULATE_READER
|
|
update_area_t myarea;
|
|
myarea.x1 = luaL_optint(L, 3, 0);
|
|
myarea.y1 = luaL_optint(L, 4, 0);
|
|
myarea.x2 = luaL_optint(L, 5, fb->vinfo.xres);
|
|
myarea.y2 = luaL_optint(L, 6, fb->vinfo.yres);
|
|
myarea.buffer = NULL;
|
|
myarea.which_fx = fxtype ? fx_update_partial : fx_update_full;
|
|
ioctl(fb->fd, FBIO_EINK_UPDATE_DISPLAY_AREA, &myarea);
|
|
#else
|
|
// for now, we only do fullscreen blits in emulation mode
|
|
if(SDL_MUSTLOCK(fb->screen) && (SDL_LockSurface(fb->screen) < 0)) {
|
|
return luaL_error(L, "can't lock surface.");
|
|
}
|
|
uint32_t *sfptr = (uint32_t*)fb->screen->pixels;
|
|
uint8_t *fbptr = (uint8_t*)fb->data;
|
|
|
|
int c = fb->finfo.smem_len;
|
|
|
|
while(c--) {
|
|
*sfptr = SDL_MapRGB(fb->screen->format,
|
|
255 - (*fbptr & 0xF0),
|
|
255 - (*fbptr & 0xF0),
|
|
255 - (*fbptr & 0xF0));
|
|
sfptr++;
|
|
*sfptr = SDL_MapRGB(fb->screen->format,
|
|
255 - ((*fbptr & 0x0F) << 4),
|
|
255 - ((*fbptr & 0x0F) << 4),
|
|
255 - ((*fbptr & 0x0F) << 4));
|
|
sfptr++;
|
|
fbptr++;
|
|
}
|
|
if(SDL_MUSTLOCK(fb->screen)) SDL_UnlockSurface(fb->screen);
|
|
SDL_Flip(fb->screen);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static const struct luaL_reg einkfb_func[] = {
|
|
{"open", openFrameBuffer},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static const struct luaL_reg einkfb_meth[] = {
|
|
{"close", closeFrameBuffer},
|
|
{"refresh", einkUpdate},
|
|
{"getSize", getSize},
|
|
{"blitFrom", blitToFrameBuffer},
|
|
{"blitFullFrom", blitFullToFrameBuffer},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
int luaopen_einkfb(lua_State *L) {
|
|
luaL_newmetatable(L, "einkfb");
|
|
lua_pushstring(L, "__index");
|
|
lua_pushvalue(L, -2);
|
|
lua_settable(L, -3);
|
|
luaL_register(L, NULL, einkfb_meth);
|
|
luaL_register(L, "einkfb", einkfb_func);
|
|
|
|
return 1;
|
|
}
|