summaryrefslogtreecommitdiffstats
path: root/minui
diff options
context:
space:
mode:
Diffstat (limited to 'minui')
-rw-r--r--minui/Android.mk7
-rw-r--r--minui/events.c86
-rw-r--r--minui/font_10x18.h2
-rw-r--r--minui/graphics.c333
-rw-r--r--minui/graphics.h50
-rw-r--r--minui/graphics_adf.c247
-rw-r--r--minui/graphics_fbdev.c217
-rw-r--r--minui/minui.h60
-rw-r--r--minui/resources.c431
9 files changed, 292 insertions, 1141 deletions
diff --git a/minui/Android.mk b/minui/Android.mk
index 7b401567d..54eb06166 100644
--- a/minui/Android.mk
+++ b/minui/Android.mk
@@ -1,7 +1,7 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
-LOCAL_SRC_FILES := graphics_adf.c graphics_fbdev.c graphics_overlay.c events.c resources.c
+LOCAL_SRC_FILES := graphics_overlay.c events.c resources.c
ifneq ($(BOARD_CUSTOM_GRAPHICS),)
LOCAL_SRC_FILES += $(BOARD_CUSTOM_GRAPHICS)
else
@@ -25,8 +25,6 @@ else
endif
LOCAL_STATIC_LIBRARY := libpng
-LOCAL_WHOLE_STATIC_LIBRARIES += libadf
-
LOCAL_MODULE := libminui
# This used to compare against values in double-quotes (which are just
@@ -62,7 +60,7 @@ include $(BUILD_STATIC_LIBRARY)
include $(CLEAR_VARS)
-LOCAL_SRC_FILES := graphics_adf.c graphics_fbdev.c graphics_overlay.c events.c resources.c
+LOCAL_SRC_FILES := graphics_overlay.c events.c resources.c
ifneq ($(BOARD_CUSTOM_GRAPHICS),)
LOCAL_SRC_FILES += $(BOARD_CUSTOM_GRAPHICS)
else
@@ -89,7 +87,6 @@ LOCAL_MODULE := libminui
LOCAL_ARM_MODE:= arm
LOCAL_SHARED_LIBRARIES := libpng libpixelflinger
-LOCAL_WHOLE_STATIC_LIBRARIES += libadf
# This used to compare against values in double-quotes (which are just
# ordinary characters in this context). Strip double-quotes from the
# value so that either will work.
diff --git a/minui/events.c b/minui/events.c
index df7dad448..2918afaa8 100644
--- a/minui/events.c
+++ b/minui/events.c
@@ -18,7 +18,7 @@
#include <stdlib.h>
#include <fcntl.h>
#include <dirent.h>
-#include <sys/epoll.h>
+#include <sys/poll.h>
#include <linux/input.h>
@@ -34,15 +34,11 @@
((array)[(bit)/BITS_PER_LONG] & (1 << ((bit) % BITS_PER_LONG)))
struct fd_info {
- int fd;
ev_callback cb;
void *data;
};
-static int epollfd;
-static struct epoll_event polledevents[MAX_DEVICES + MAX_MISC_FDS];
-static int npolledevents;
-
+static struct pollfd ev_fds[MAX_DEVICES + MAX_MISC_FDS];
static struct fd_info ev_fdinfo[MAX_DEVICES + MAX_MISC_FDS];
static unsigned ev_count = 0;
@@ -54,12 +50,6 @@ int ev_init(ev_callback input_cb, void *data)
DIR *dir;
struct dirent *de;
int fd;
- struct epoll_event ev;
- bool epollctlfail = false;
-
- epollfd = epoll_create(MAX_DEVICES + MAX_MISC_FDS);
- if (epollfd == -1)
- return -1;
dir = opendir("/dev/input");
if(dir != 0) {
@@ -84,15 +74,8 @@ int ev_init(ev_callback input_cb, void *data)
continue;
}
- ev.events = EPOLLIN | EPOLLWAKEUP;
- ev.data.ptr = (void *)&ev_fdinfo[ev_count];
- if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev)) {
- close(fd);
- epollctlfail = true;
- continue;
- }
-
- ev_fdinfo[ev_count].fd = fd;
+ ev_fds[ev_count].fd = fd;
+ ev_fds[ev_count].events = POLLIN;
ev_fdinfo[ev_count].cb = input_cb;
ev_fdinfo[ev_count].data = data;
ev_count++;
@@ -101,78 +84,59 @@ int ev_init(ev_callback input_cb, void *data)
}
}
- if (epollctlfail && !ev_count) {
- close(epollfd);
- epollfd = -1;
- return -1;
- }
-
return 0;
}
int ev_add_fd(int fd, ev_callback cb, void *data)
{
- struct epoll_event ev;
- int ret;
-
if (ev_misc_count == MAX_MISC_FDS || cb == NULL)
return -1;
- ev.events = EPOLLIN | EPOLLWAKEUP;
- ev.data.ptr = (void *)&ev_fdinfo[ev_count];
- ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
- if (!ret) {
- ev_fdinfo[ev_count].fd = fd;
- ev_fdinfo[ev_count].cb = cb;
- ev_fdinfo[ev_count].data = data;
- ev_count++;
- ev_misc_count++;
- }
-
- return ret;
-}
-
-int ev_get_epollfd(void)
-{
- return epollfd;
+ ev_fds[ev_count].fd = fd;
+ ev_fds[ev_count].events = POLLIN;
+ ev_fdinfo[ev_count].cb = cb;
+ ev_fdinfo[ev_count].data = data;
+ ev_count++;
+ ev_misc_count++;
+ return 0;
}
void ev_exit(void)
{
while (ev_count > 0) {
- close(ev_fdinfo[--ev_count].fd);
+ close(ev_fds[--ev_count].fd);
}
ev_misc_count = 0;
ev_dev_count = 0;
- close(epollfd);
}
int ev_wait(int timeout)
{
- npolledevents = epoll_wait(epollfd, polledevents, ev_count, timeout);
- if (npolledevents <= 0)
+ int r;
+
+ r = poll(ev_fds, ev_count, timeout);
+ if (r <= 0)
return -1;
return 0;
}
void ev_dispatch(void)
{
- int n;
+ unsigned n;
int ret;
- for (n = 0; n < npolledevents; n++) {
- struct fd_info *fdi = polledevents[n].data.ptr;
- ev_callback cb = fdi->cb;
- if (cb)
- cb(fdi->fd, polledevents[n].events, fdi->data);
+ for (n = 0; n < ev_count; n++) {
+ ev_callback cb = ev_fdinfo[n].cb;
+ if (cb && (ev_fds[n].revents & ev_fds[n].events))
+ cb(ev_fds[n].fd, ev_fds[n].revents, ev_fdinfo[n].data);
}
}
-int ev_get_input(int fd, uint32_t epevents, struct input_event *ev)
+int ev_get_input(int fd, short revents, struct input_event *ev)
{
int r;
- if (epevents & EPOLLIN) {
+ if (revents & POLLIN) {
r = read(fd, ev, sizeof(*ev));
if (r == sizeof(*ev))
return 0;
@@ -193,11 +157,11 @@ int ev_sync_key_state(ev_set_key_callback set_key_cb, void *data)
memset(key_bits, 0, sizeof(key_bits));
memset(ev_bits, 0, sizeof(ev_bits));
- ret = ioctl(ev_fdinfo[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits);
+ ret = ioctl(ev_fds[i].fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits);
if (ret < 0 || !test_bit(EV_KEY, ev_bits))
continue;
- ret = ioctl(ev_fdinfo[i].fd, EVIOCGKEY(sizeof(key_bits)), key_bits);
+ ret = ioctl(ev_fds[i].fd, EVIOCGKEY(sizeof(key_bits)), key_bits);
if (ret < 0)
continue;
diff --git a/minui/font_10x18.h b/minui/font_10x18.h
index 29d705344..7f96465cc 100644
--- a/minui/font_10x18.h
+++ b/minui/font_10x18.h
@@ -3,7 +3,7 @@ struct {
unsigned height;
unsigned cwidth;
unsigned cheight;
- unsigned char rundata[2973];
+ unsigned char rundata[];
} font = {
.width = 960,
.height = 18,
diff --git a/minui/graphics.c b/minui/graphics.c
index 470e735c9..8f951756d 100644
--- a/minui/graphics.c
+++ b/minui/graphics.c
@@ -29,34 +29,44 @@
#include <linux/fb.h>
#include <linux/kd.h>
-#include <time.h>
+#include <pixelflinger/pixelflinger.h>
#include "font_10x18.h"
#include "minui.h"
-#include "graphics.h"
+
+#if defined(RECOVERY_BGRA)
+#define PIXEL_FORMAT GGL_PIXEL_FORMAT_BGRA_8888
+#define PIXEL_SIZE 4
+#elif defined(RECOVERY_RGBX)
+#define PIXEL_FORMAT GGL_PIXEL_FORMAT_RGBX_8888
+#define PIXEL_SIZE 4
+#else
+#define PIXEL_FORMAT GGL_PIXEL_FORMAT_RGB_565
+#define PIXEL_SIZE 2
+#endif
+
+#define NUM_BUFFERS 2
typedef struct {
- GRSurface* texture;
- int cwidth;
- int cheight;
+ GGLSurface* texture;
+ unsigned cwidth;
+ unsigned cheight;
} GRFont;
-static GRFont* gr_font = NULL;
-static minui_backend* gr_backend = NULL;
-
+static GRFont *gr_font = 0;
+static GGLContext *gr_context = 0;
+static GGLSurface gr_font_texture;
+static GGLSurface gr_framebuffer[NUM_BUFFERS];
+static GGLSurface gr_mem_surface;
+static unsigned gr_active_fb = 0;
+static unsigned double_buffering = 0;
static int overscan_percent = OVERSCAN_PERCENT;
static int overscan_offset_x = 0;
static int overscan_offset_y = 0;
+static int gr_fb_fd = -1;
static int gr_vt_fd = -1;
-static unsigned char gr_current_r = 255;
-static unsigned char gr_current_g = 255;
-static unsigned char gr_current_b = 255;
-static unsigned char gr_current_a = 255;
-
-static GRSurface* gr_draw = NULL;
-
static struct fb_var_screeninfo vi;
static struct fb_fix_screeninfo fi;
@@ -157,6 +167,8 @@ static int get_framebuffer(GGLSurface *fb)
if (vi.yres * fi.line_length * 2 > fi.smem_len)
return fd;
+ double_buffering = 1;
+
fb->version = sizeof(*fb);
fb->width = vi.xres;
fb->height = vi.yres;
@@ -221,11 +233,6 @@ void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a
gl->color4xv(gl, color);
}
-static bool outside(int x, int y)
-{
- return x < 0 || x >= gr_draw->width || y < 0 || y >= gr_draw->height;
-}
-
int gr_measure(const char *s)
{
return gr_font->cwidth * strlen(s);
@@ -242,118 +249,58 @@ int gr_text(int x, int y, const char *s, ...)
return gr_text_impl(x, y, s, 0);
}
-static void text_blend(unsigned char* src_p, int src_row_bytes,
- unsigned char* dst_p, int dst_row_bytes,
- int width, int height)
-{
- int i, j;
- for (j = 0; j < height; ++j) {
- unsigned char* sx = src_p;
- unsigned char* px = dst_p;
- for (i = 0; i < width; ++i) {
- unsigned char a = *sx++;
- if (gr_current_a < 255) a = ((int)a * gr_current_a) / 255;
- if (a == 255) {
- *px++ = gr_current_r;
- *px++ = gr_current_g;
- *px++ = gr_current_b;
- px++;
- } else if (a > 0) {
- *px = (*px * (255-a) + gr_current_r * a) / 255;
- ++px;
- *px = (*px * (255-a) + gr_current_g * a) / 255;
- ++px;
- *px = (*px * (255-a) + gr_current_b * a) / 255;
- ++px;
- ++px;
- } else {
- px += 4;
- }
- }
- src_p += src_row_bytes;
- dst_p += dst_row_bytes;
- }
-}
-
-
int gr_text_impl(int x, int y, const char *s, int bold)
{
+ GGLContext *gl = gr_context;
GRFont *font = gr_font;
unsigned off;
- if (!font->texture) return;
- if (gr_current_a == 0) return;
+ if (!font->texture) return x;
bold = bold && (font->texture->height != font->cheight);
x += overscan_offset_x;
y += overscan_offset_y;
+ gl->bindTexture(gl, font->texture);
+ gl->texEnvi(gl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE);
+ gl->texGeni(gl, GGL_S, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
+ gl->texGeni(gl, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
+ gl->enable(gl, GGL_TEXTURE_2D);
+
while((off = *s++)) {
off -= 32;
- if (outside(x, y) || outside(x+font->cwidth-1, y+font->cheight-1)) break;
if (off < 96) {
-
- unsigned char* src_p = font->texture->data + (off * font->cwidth) +
- (bold ? font->cheight * font->texture->row_bytes : 0);
- unsigned char* dst_p = gr_draw->data + y*gr_draw->row_bytes + x*gr_draw->pixel_bytes;
-
- text_blend(src_p, font->texture->row_bytes,
- dst_p, gr_draw->row_bytes,
- font->cwidth, font->cheight);
-
+ gl->texCoord2i(gl, (off * font->cwidth) - x,
+ (bold ? font->cheight : 0) - y);
+ gl->recti(gl, x, y, x + font->cwidth, y + font->cheight);
}
x += font->cwidth;
}
-}
-void gr_texticon(int x, int y, GRSurface* icon) {
- if (icon == NULL) return;
+ return x;
+}
- if (icon->pixel_bytes != 1) {
- printf("gr_texticon: source has wrong format\n");
+void gr_texticon(int x, int y, gr_surface icon) {
+ if (gr_context == NULL || icon == NULL) {
return;
}
+ GGLContext* gl = gr_context;
x += overscan_offset_x;
y += overscan_offset_y;
- if (outside(x, y) || outside(x+icon->width-1, y+icon->height-1)) return;
+ gl->bindTexture(gl, (GGLSurface*) icon);
+ gl->texEnvi(gl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE);
+ gl->texGeni(gl, GGL_S, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
+ gl->texGeni(gl, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
+ gl->enable(gl, GGL_TEXTURE_2D);
- unsigned char* src_p = icon->data;
- unsigned char* dst_p = gr_draw->data + y*gr_draw->row_bytes + x*gr_draw->pixel_bytes;
+ int w = gr_get_width(icon);
+ int h = gr_get_height(icon);
- text_blend(src_p, icon->row_bytes,
- dst_p, gr_draw->row_bytes,
- icon->width, icon->height);
-}
-
-void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
-{
- gr_current_r = r;
- gr_current_g = g;
- gr_current_b = b;
- gr_current_a = a;
-}
-
-void gr_clear()
-{
- if (gr_current_r == gr_current_g &&
- gr_current_r == gr_current_b) {
- memset(gr_draw->data, gr_current_r, gr_draw->height * gr_draw->row_bytes);
- } else {
- int x, y;
- unsigned char* px = gr_draw->data;
- for (y = 0; y < gr_draw->height; ++y) {
- for (x = 0; x < gr_draw->width; ++x) {
- *px++ = gr_current_r;
- *px++ = gr_current_g;
- *px++ = gr_current_b;
- px++;
- }
- px += gr_draw->row_bytes - (gr_draw->width * gr_draw->pixel_bytes);
- }
- }
+ gl->texCoord2i(gl, -x, -y);
+ gl->recti(gl, x, y, x+gr_get_width(icon), y+gr_get_height(icon));
}
void gr_fill(int x1, int y1, int x2, int y2)
@@ -364,82 +311,48 @@ void gr_fill(int x1, int y1, int x2, int y2)
x2 += overscan_offset_x;
y2 += overscan_offset_y;
- if (outside(x1, y1) || outside(x2-1, y2-1)) return;
-
- unsigned char* p = gr_draw->data + y1 * gr_draw->row_bytes + x1 * gr_draw->pixel_bytes;
- if (gr_current_a == 255) {
- int x, y;
- for (y = y1; y < y2; ++y) {
- unsigned char* px = p;
- for (x = x1; x < x2; ++x) {
- *px++ = gr_current_r;
- *px++ = gr_current_g;
- *px++ = gr_current_b;
- px++;
- }
- p += gr_draw->row_bytes;
- }
- } else if (gr_current_a > 0) {
- int x, y;
- for (y = y1; y < y2; ++y) {
- unsigned char* px = p;
- for (x = x1; x < x2; ++x) {
- *px = (*px * (255-gr_current_a) + gr_current_r * gr_current_a) / 255;
- ++px;
- *px = (*px * (255-gr_current_a) + gr_current_g * gr_current_a) / 255;
- ++px;
- *px = (*px * (255-gr_current_a) + gr_current_b * gr_current_a) / 255;
- ++px;
- ++px;
- }
- p += gr_draw->row_bytes;
- }
- }
+ GGLContext *gl = gr_context;
+ gl->disable(gl, GGL_TEXTURE_2D);
+ gl->recti(gl, x1, y1, x2, y2);
}
-void gr_blit(GRSurface* source, int sx, int sy, int w, int h, int dx, int dy) {
- if (source == NULL) return;
-
- if (gr_draw->pixel_bytes != source->pixel_bytes) {
- printf("gr_blit: source has wrong format\n");
+void gr_blit(gr_surface source, int sx, int sy, int w, int h, int dx, int dy) {
+ if (gr_context == NULL || source == NULL) {
return;
}
+ GGLContext *gl = gr_context;
dx += overscan_offset_x;
dy += overscan_offset_y;
- if (outside(dx, dy) || outside(dx+w-1, dy+h-1)) return;
-
- unsigned char* src_p = source->data + sy*source->row_bytes + sx*source->pixel_bytes;
- unsigned char* dst_p = gr_draw->data + dy*gr_draw->row_bytes + dx*gr_draw->pixel_bytes;
-
- int i;
- for (i = 0; i < h; ++i) {
- memcpy(dst_p, src_p, w * source->pixel_bytes);
- src_p += source->row_bytes;
- dst_p += gr_draw->row_bytes;
- }
+ gl->bindTexture(gl, (GGLSurface*) source);
+ gl->texEnvi(gl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE);
+ gl->texGeni(gl, GGL_S, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
+ gl->texGeni(gl, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
+ gl->enable(gl, GGL_TEXTURE_2D);
+ gl->texCoord2i(gl, sx - dx, sy - dy);
+ gl->recti(gl, dx, dy, dx + w, dy + h);
}
-unsigned int gr_get_width(GRSurface* surface) {
+unsigned int gr_get_width(gr_surface surface) {
if (surface == NULL) {
return 0;
}
- return surface->width;
+ return ((GGLSurface*) surface)->width;
}
-unsigned int gr_get_height(GRSurface* surface) {
+unsigned int gr_get_height(gr_surface surface) {
if (surface == NULL) {
return 0;
}
- return surface->height;
+ return ((GGLSurface*) surface)->height;
}
static void gr_init_font(void)
{
gr_font = calloc(sizeof(*gr_font), 1);
- int res = res_create_alpha_surface("font", &(gr_font->texture));
+ int res = res_create_surface("font", (void**)&(gr_font->texture));
if (res == 0) {
// The font image should be a 96x2 array of character images. The
// columns are the printable ASCII characters 0x20 - 0x7f. The
@@ -453,8 +366,7 @@ static void gr_init_font(void)
gr_font->texture = malloc(sizeof(*gr_font->texture));
gr_font->texture->width = font.width;
gr_font->texture->height = font.height;
- gr_font->texture->row_bytes = font.width;
- gr_font->texture->pixel_bytes = 1;
+ gr_font->texture->stride = font.width;
unsigned char* bits = malloc(font.width * font.height);
gr_font->texture->data = (void*) bits;
@@ -469,65 +381,17 @@ static void gr_init_font(void)
gr_font->cwidth = font.cwidth;
gr_font->cheight = font.cheight;
}
-}
-
-#if 0
-// Exercises many of the gr_*() functions; useful for testing.
-static void gr_test() {
- GRSurface** images;
- int frames;
- int result = res_create_multi_surface("icon_installing", &frames, &images);
- if (result < 0) {
- printf("create surface %d\n", result);
- gr_exit();
- return;
- }
- time_t start = time(NULL);
- int x;
- for (x = 0; x <= 1200; ++x) {
- if (x < 400) {
- gr_color(0, 0, 0, 255);
- } else {
- gr_color(0, (x-400)%128, 0, 255);
- }
- gr_clear();
-
- gr_color(255, 0, 0, 255);
- gr_surface frame = images[x%frames];
- gr_blit(frame, 0, 0, frame->width, frame->height, x, 0);
-
- gr_color(255, 0, 0, 128);
- gr_fill(400, 150, 600, 350);
-
- gr_color(255, 255, 255, 255);
- gr_text(500, 225, "hello, world!", 0);
- gr_color(255, 255, 0, 128);
- gr_text(300+x, 275, "pack my box with five dozen liquor jugs", 1);
-
- gr_color(0, 0, 255, 128);
- gr_fill(gr_draw->width - 200 - x, 300, gr_draw->width - x, 500);
-
- gr_draw = gr_backend->flip(gr_backend);
- }
- printf("getting end time\n");
- time_t end = time(NULL);
- printf("got end time\n");
- printf("start %ld end %ld\n", (long)start, (long)end);
- if (end > start) {
- printf("%.2f fps\n", ((double)x) / (end-start));
- }
-}
-#endif
-
-void gr_flip() {
- gr_draw = gr_backend->flip(gr_backend);
+ // interpret the grayscale as alpha
+ gr_font->texture->format = GGL_PIXEL_FORMAT_A_8;
}
int gr_init(void)
{
- gr_init_font();
+ gglInit(&gr_context);
+ GGLContext *gl = gr_context;
+ gr_init_font();
gr_vt_fd = open("/dev/tty0", O_RDWR | O_SYNC);
if (gr_vt_fd < 0) {
// This is non-fatal; post-Cupcake kernels don't have tty0.
@@ -539,12 +403,10 @@ int gr_init(void)
return -1;
}
- gr_backend = open_adf();
- if (gr_backend) {
- gr_draw = gr_backend->init(gr_backend);
- if (!gr_draw) {
- gr_backend->exit(gr_backend);
- }
+ gr_fb_fd = get_framebuffer(gr_framebuffer);
+ if (gr_fb_fd < 0) {
+ gr_exit();
+ return -1;
}
get_memory_surface(&gr_mem_surface);
@@ -558,19 +420,12 @@ int gr_init(void)
set_active_framebuffer(0);
gl->colorBuffer(gl, &gr_mem_surface);
- if (!gr_draw) {
- gr_backend = open_fbdev();
- gr_draw = gr_backend->init(gr_backend);
- if (gr_draw == NULL) {
- return -1;
- }
- }
-
- overscan_offset_x = gr_draw->width * overscan_percent / 100;
- overscan_offset_y = gr_draw->height * overscan_percent / 100;
+ gl->activeTexture(gl, 0);
+ gl->enable(gl, GGL_BLEND);
+ gl->blendFunc(gl, GGL_SRC_ALPHA, GGL_ONE_MINUS_SRC_ALPHA);
- gr_flip();
- gr_flip();
+ gr_fb_blank(true);
+ gr_fb_blank(false);
if (!alloc_ion_mem(fi.line_length * vi.yres))
allocate_overlay(gr_fb_fd, gr_framebuffer);
@@ -588,8 +443,6 @@ void gr_exit(void)
free(gr_mem_surface.data);
- gr_backend->exit(gr_backend);
-
ioctl(gr_vt_fd, KDSETMODE, (void*) KD_TEXT);
close(gr_vt_fd);
gr_vt_fd = -1;
@@ -597,12 +450,17 @@ void gr_exit(void)
int gr_fb_width(void)
{
- return gr_draw->width - 2*overscan_offset_x;
+ return gr_framebuffer[0].width - 2*overscan_offset_x;
}
int gr_fb_height(void)
{
- return gr_draw->height - 2*overscan_offset_y;
+ return gr_framebuffer[0].height - 2*overscan_offset_y;
+}
+
+gr_pixel *gr_fb_data(void)
+{
+ return (unsigned short *) gr_mem_surface.data;
}
void gr_fb_blank(bool blank)
@@ -620,11 +478,14 @@ void gr_fb_blank(bool blank)
write(fd, blank ? "000" : brightness, 3);
close(fd);
#else
- gr_backend->blank(gr_backend, blank);
-
+ int ret;
if (blank)
free_overlay(gr_fb_fd);
+ ret = ioctl(gr_fb_fd, FBIOBLANK, blank ? FB_BLANK_POWERDOWN : FB_BLANK_UNBLANK);
+ if (ret < 0)
+ perror("ioctl(): blank");
+
if (!blank)
allocate_overlay(gr_fb_fd, gr_framebuffer);
#endif
diff --git a/minui/graphics.h b/minui/graphics.h
deleted file mode 100644
index 993e986ee..000000000
--- a/minui/graphics.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef _GRAPHICS_H_
-#define _GRAPHICS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdbool.h>
-#include "minui.h"
-
-typedef struct minui_backend {
- // Initializes the backend and returns a gr_surface to draw into.
- gr_surface (*init)(struct minui_backend*);
-
- // Causes the current drawing surface (returned by the most recent
- // call to flip() or init()) to be displayed, and returns a new
- // drawing surface.
- gr_surface (*flip)(struct minui_backend*);
-
- // Blank (or unblank) the screen.
- void (*blank)(struct minui_backend*, bool);
-
- // Device cleanup when drawing is done.
- void (*exit)(struct minui_backend*);
-} minui_backend;
-
-minui_backend* open_fbdev();
-minui_backend* open_adf();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/minui/graphics_adf.c b/minui/graphics_adf.c
deleted file mode 100644
index ac6d64e9e..000000000
--- a/minui/graphics_adf.c
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * Copyright (C) 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include <sys/cdefs.h>
-#include <sys/mman.h>
-
-#include <adf/adf.h>
-
-#include "graphics.h"
-
-struct adf_surface_pdata {
- GRSurface base;
- int fd;
- __u32 offset;
- __u32 pitch;
-};
-
-struct adf_pdata {
- minui_backend base;
- int intf_fd;
- adf_id_t eng_id;
- __u32 format;
-
- unsigned int current_surface;
- unsigned int n_surfaces;
- struct adf_surface_pdata surfaces[2];
-};
-
-static gr_surface adf_flip(struct minui_backend *backend);
-static void adf_blank(struct minui_backend *backend, bool blank);
-
-static int adf_surface_init(struct adf_pdata *pdata,
- struct drm_mode_modeinfo *mode, struct adf_surface_pdata *surf)
-{
- memset(surf, 0, sizeof(*surf));
-
- surf->fd = adf_interface_simple_buffer_alloc(pdata->intf_fd, mode->hdisplay,
- mode->vdisplay, pdata->format, &surf->offset, &surf->pitch);
- if (surf->fd < 0)
- return surf->fd;
-
- surf->base.width = mode->hdisplay;
- surf->base.height = mode->vdisplay;
- surf->base.row_bytes = surf->pitch;
- surf->base.pixel_bytes = (pdata->format == DRM_FORMAT_RGB565) ? 2 : 4;
-
- surf->base.data = mmap(NULL, surf->pitch * surf->base.height, PROT_WRITE,
- MAP_SHARED, surf->fd, surf->offset);
- if (surf->base.data == MAP_FAILED) {
- close(surf->fd);
- return -errno;
- }
-
- return 0;
-}
-
-static int adf_interface_init(struct adf_pdata *pdata)
-{
- struct adf_interface_data intf_data;
- int ret = 0;
- int err;
-
- err = adf_get_interface_data(pdata->intf_fd, &intf_data);
- if (err < 0)
- return err;
-
- err = adf_surface_init(pdata, &intf_data.current_mode, &pdata->surfaces[0]);
- if (err < 0) {
- fprintf(stderr, "allocating surface 0 failed: %s\n", strerror(-err));
- ret = err;
- goto done;
- }
-
- err = adf_surface_init(pdata, &intf_data.current_mode,
- &pdata->surfaces[1]);
- if (err < 0) {
- fprintf(stderr, "allocating surface 1 failed: %s\n", strerror(-err));
- memset(&pdata->surfaces[1], 0, sizeof(pdata->surfaces[1]));
- pdata->n_surfaces = 1;
- } else {
- pdata->n_surfaces = 2;
- }
-
-done:
- adf_free_interface_data(&intf_data);
- return ret;
-}
-
-static int adf_device_init(struct adf_pdata *pdata, struct adf_device *dev)
-{
- adf_id_t intf_id;
- int intf_fd;
- int err;
-
- err = adf_find_simple_post_configuration(dev, &pdata->format, 1, &intf_id,
- &pdata->eng_id);
- if (err < 0)
- return err;
-
- err = adf_device_attach(dev, pdata->eng_id, intf_id);
- if (err < 0 && err != -EALREADY)
- return err;
-
- pdata->intf_fd = adf_interface_open(dev, intf_id, O_RDWR);
- if (pdata->intf_fd < 0)
- return pdata->intf_fd;
-
- err = adf_interface_init(pdata);
- if (err < 0) {
- close(pdata->intf_fd);
- pdata->intf_fd = -1;
- }
-
- return err;
-}
-
-static gr_surface adf_init(minui_backend *backend)
-{
- struct adf_pdata *pdata = (struct adf_pdata *)backend;
- adf_id_t *dev_ids = NULL;
- ssize_t n_dev_ids, i;
- gr_surface ret;
-
-#if defined(RECOVERY_BGRA)
- pdata->format = DRM_FORMAT_BGRA8888;
-#elif defined(RECOVERY_RGBX)
- pdata->format = DRM_FORMAT_RGBX8888;
-#else
- pdata->format = DRM_FORMAT_RGB565;
-#endif
-
- n_dev_ids = adf_devices(&dev_ids);
- if (n_dev_ids == 0) {
- return NULL;
- } else if (n_dev_ids < 0) {
- fprintf(stderr, "enumerating adf devices failed: %s\n",
- strerror(-n_dev_ids));
- return NULL;
- }
-
- pdata->intf_fd = -1;
-
- for (i = 0; i < n_dev_ids && pdata->intf_fd < 0; i++) {
- struct adf_device dev;
-
- int err = adf_device_open(dev_ids[i], O_RDWR, &dev);
- if (err < 0) {
- fprintf(stderr, "opening adf device %u failed: %s\n", dev_ids[i],
- strerror(-err));
- continue;
- }
-
- err = adf_device_init(pdata, &dev);
- if (err < 0)
- fprintf(stderr, "initializing adf device %u failed: %s\n",
- dev_ids[i], strerror(-err));
-
- adf_device_close(&dev);
- }
-
- free(dev_ids);
-
- if (pdata->intf_fd < 0)
- return NULL;
-
- ret = adf_flip(backend);
-
- adf_blank(backend, true);
- adf_blank(backend, false);
-
- return ret;
-}
-
-static gr_surface adf_flip(struct minui_backend *backend)
-{
- struct adf_pdata *pdata = (struct adf_pdata *)backend;
- struct adf_surface_pdata *surf = &pdata->surfaces[pdata->current_surface];
-
- int fence_fd = adf_interface_simple_post(pdata->intf_fd, pdata->eng_id,
- surf->base.width, surf->base.height, pdata->format, surf->fd,
- surf->offset, surf->pitch, -1);
- if (fence_fd >= 0)
- close(fence_fd);
-
- pdata->current_surface = (pdata->current_surface + 1) % pdata->n_surfaces;
- return &pdata->surfaces[pdata->current_surface].base;
-}
-
-static void adf_blank(struct minui_backend *backend, bool blank)
-{
- struct adf_pdata *pdata = (struct adf_pdata *)backend;
- adf_interface_blank(pdata->intf_fd,
- blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON);
-}
-
-static void adf_surface_destroy(struct adf_surface_pdata *surf)
-{
- munmap(surf->base.data, surf->pitch * surf->base.height);
- close(surf->fd);
-}
-
-static void adf_exit(struct minui_backend *backend)
-{
- struct adf_pdata *pdata = (struct adf_pdata *)backend;
- unsigned int i;
-
- for (i = 0; i < pdata->n_surfaces; i++)
- adf_surface_destroy(&pdata->surfaces[i]);
- if (pdata->intf_fd >= 0)
- close(pdata->intf_fd);
- free(pdata);
-}
-
-minui_backend *open_adf()
-{
- struct adf_pdata *pdata = calloc(1, sizeof(*pdata));
- if (!pdata) {
- perror("allocating adf backend failed");
- return NULL;
- }
-
- pdata->base.init = adf_init;
- pdata->base.flip = adf_flip;
- pdata->base.blank = adf_blank;
- pdata->base.exit = adf_exit;
- return &pdata->base;
-}
diff --git a/minui/graphics_fbdev.c b/minui/graphics_fbdev.c
deleted file mode 100644
index c0c1bcb1a..000000000
--- a/minui/graphics_fbdev.c
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Copyright (C) 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdbool.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include <fcntl.h>
-#include <stdio.h>
-
-#include <sys/cdefs.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-
-#include <linux/fb.h>
-#include <linux/kd.h>
-
-#include "minui.h"
-#include "graphics.h"
-
-static gr_surface fbdev_init(minui_backend*);
-static gr_surface fbdev_flip(minui_backend*);
-static void fbdev_blank(minui_backend*, bool);
-static void fbdev_exit(minui_backend*);
-
-static GRSurface gr_framebuffer[2];
-static bool double_buffered;
-static GRSurface* gr_draw = NULL;
-static int displayed_buffer;
-
-static struct fb_var_screeninfo vi;
-static int fb_fd = -1;
-
-static minui_backend my_backend = {
- .init = fbdev_init,
- .flip = fbdev_flip,
- .blank = fbdev_blank,
- .exit = fbdev_exit,
-};
-
-minui_backend* open_fbdev() {
- return &my_backend;
-}
-
-static void fbdev_blank(minui_backend* backend __unused, bool blank)
-{
- int ret;
-
- ret = ioctl(fb_fd, FBIOBLANK, blank ? FB_BLANK_POWERDOWN : FB_BLANK_UNBLANK);
- if (ret < 0)
- perror("ioctl(): blank");
-}
-
-static void set_displayed_framebuffer(unsigned n)
-{
- if (n > 1 || !double_buffered) return;
-
- vi.yres_virtual = gr_framebuffer[0].height * 2;
- vi.yoffset = n * gr_framebuffer[0].height;
- vi.bits_per_pixel = gr_framebuffer[0].pixel_bytes * 8;
- if (ioctl(fb_fd, FBIOPUT_VSCREENINFO, &vi) < 0) {
- perror("active fb swap failed");
- }
- displayed_buffer = n;
-}
-
-static gr_surface fbdev_init(minui_backend* backend) {
- int fd;
- void *bits;
-
- struct fb_fix_screeninfo fi;
-
- fd = open("/dev/graphics/fb0", O_RDWR);
- if (fd < 0) {
- perror("cannot open fb0");
- return NULL;
- }
-
- if (ioctl(fd, FBIOGET_FSCREENINFO, &fi) < 0) {
- perror("failed to get fb0 info");
- close(fd);
- return NULL;
- }
-
- if (ioctl(fd, FBIOGET_VSCREENINFO, &vi) < 0) {
- perror("failed to get fb0 info");
- close(fd);
- return NULL;
- }
-
- // We print this out for informational purposes only, but
- // throughout we assume that the framebuffer device uses an RGBX
- // pixel format. This is the case for every development device I
- // have access to. For some of those devices (eg, hammerhead aka
- // Nexus 5), FBIOGET_VSCREENINFO *reports* that it wants a
- // different format (XBGR) but actually produces the correct
- // results on the display when you write RGBX.
- //
- // If you have a device that actually *needs* another pixel format
- // (ie, BGRX, or 565), patches welcome...
-
- printf("fb0 reports (possibly inaccurate):\n"
- " vi.bits_per_pixel = %d\n"
- " vi.red.offset = %3d .length = %3d\n"
- " vi.green.offset = %3d .length = %3d\n"
- " vi.blue.offset = %3d .length = %3d\n",
- vi.bits_per_pixel,
- vi.red.offset, vi.red.length,
- vi.green.offset, vi.green.length,
- vi.blue.offset, vi.blue.length);
-
- bits = mmap(0, fi.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
- if (bits == MAP_FAILED) {
- perror("failed to mmap framebuffer");
- close(fd);
- return NULL;
- }
-
- memset(bits, 0, fi.smem_len);
-
- gr_framebuffer[0].width = vi.xres;
- gr_framebuffer[0].height = vi.yres;
- gr_framebuffer[0].row_bytes = fi.line_length;
- gr_framebuffer[0].pixel_bytes = vi.bits_per_pixel / 8;
- gr_framebuffer[0].data = bits;
- memset(gr_framebuffer[0].data, 0, gr_framebuffer[0].height * gr_framebuffer[0].row_bytes);
-
- /* check if we can use double buffering */
- if (vi.yres * fi.line_length * 2 <= fi.smem_len) {
- double_buffered = true;
-
- memcpy(gr_framebuffer+1, gr_framebuffer, sizeof(GRSurface));
- gr_framebuffer[1].data = gr_framebuffer[0].data +
- gr_framebuffer[0].height * gr_framebuffer[0].row_bytes;
-
- gr_draw = gr_framebuffer+1;
-
- } else {
- double_buffered = false;
-
- // Without double-buffering, we allocate RAM for a buffer to
- // draw in, and then "flipping" the buffer consists of a
- // memcpy from the buffer we allocated to the framebuffer.
-
- gr_draw = (GRSurface*) malloc(sizeof(GRSurface));
- memcpy(gr_draw, gr_framebuffer, sizeof(GRSurface));
- gr_draw->data = (unsigned char*) malloc(gr_draw->height * gr_draw->row_bytes);
- if (!gr_draw->data) {
- perror("failed to allocate in-memory surface");
- return NULL;
- }
- }
-
- memset(gr_draw->data, 0, gr_draw->height * gr_draw->row_bytes);
- fb_fd = fd;
- set_displayed_framebuffer(0);
-
- printf("framebuffer: %d (%d x %d)\n", fb_fd, gr_draw->width, gr_draw->height);
-
- fbdev_blank(backend, true);
- fbdev_blank(backend, false);
-
- return gr_draw;
-}
-
-static gr_surface fbdev_flip(minui_backend* backend __unused) {
- if (double_buffered) {
- // Change gr_draw to point to the buffer currently displayed,
- // then flip the driver so we're displaying the other buffer
- // instead.
- gr_draw = gr_framebuffer + displayed_buffer;
- set_displayed_framebuffer(1-displayed_buffer);
- } else {
- // Copy from the in-memory surface to the framebuffer.
-
-#if defined(RECOVERY_BGRA)
- unsigned int idx;
- unsigned char* ucfb_vaddr = (unsigned char*)gr_framebuffer[0].data;
- unsigned char* ucbuffer_vaddr = (unsigned char*)gr_draw->data;
- for (idx = 0 ; idx < (gr_draw->height * gr_draw->row_bytes); idx += 4) {
- ucfb_vaddr[idx ] = ucbuffer_vaddr[idx + 2];
- ucfb_vaddr[idx + 1] = ucbuffer_vaddr[idx + 1];
- ucfb_vaddr[idx + 2] = ucbuffer_vaddr[idx ];
- ucfb_vaddr[idx + 3] = ucbuffer_vaddr[idx + 3];
- }
-#else
- memcpy(gr_framebuffer[0].data, gr_draw->data,
- gr_draw->height * gr_draw->row_bytes);
-#endif
- }
- return gr_draw;
-}
-
-static void fbdev_exit(minui_backend* backend __unused) {
- close(fb_fd);
- fb_fd = -1;
-
- if (!double_buffered && gr_draw) {
- free(gr_draw->data);
- free(gr_draw);
- }
- gr_draw = NULL;
-}
diff --git a/minui/minui.h b/minui/minui.h
index 82282486d..103318aa7 100644
--- a/minui/minui.h
+++ b/minui/minui.h
@@ -17,34 +17,24 @@
#ifndef _MINUI_H_
#define _MINUI_H_
-#include <sys/types.h>
-
#include <stdbool.h>
#ifdef __cplusplus
extern "C" {
#endif
-typedef struct {
- int width;
- int height;
- int row_bytes;
- int pixel_bytes;
- unsigned char* data;
-} GRSurface;
-
-typedef GRSurface* gr_surface;
+typedef void* gr_surface;
+typedef unsigned short gr_pixel;
int gr_init(void);
void gr_exit(void);
int gr_fb_width(void);
int gr_fb_height(void);
-
+gr_pixel *gr_fb_data(void);
void gr_flip(void);
void gr_fb_blank(bool blank);
-void gr_clear(); // clear entire surface to current color
void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
void gr_fill(int x1, int y1, int x2, int y2);
@@ -53,7 +43,7 @@ void gr_fill(int x1, int y1, int x2, int y2);
int gr_text(int x, int y, const char *s, ...);
int gr_text_impl(int x, int y, const char *s, int bold);
-void gr_texticon(int x, int y, gr_surface icon);
+ void gr_texticon(int x, int y, gr_surface icon);
int gr_measure(const char *s);
void gr_font_size(int *x, int *y);
void gr_get_memory_surface(gr_surface);
@@ -66,7 +56,7 @@ unsigned int gr_get_height(gr_surface surface);
// see http://www.mjmwired.net/kernel/Documentation/input/ for info.
struct input_event;
-typedef int (*ev_callback)(int fd, uint32_t epevents, void *data);
+typedef int (*ev_callback)(int fd, short revents, void *data);
typedef int (*ev_set_key_callback)(int code, int value, void *data);
int ev_init(ev_callback input_cb, void *data);
@@ -81,46 +71,14 @@ int ev_sync_key_state(ev_set_key_callback set_key_cb, void *data);
*/
int ev_wait(int timeout);
-int ev_get_input(int fd, uint32_t epevents, struct input_event *ev);
+int ev_get_input(int fd, short revents, struct input_event *ev);
void ev_dispatch(void);
-int ev_get_epollfd(void);
// Resources
-// res_create_*_surface() functions return 0 if no error, else
-// negative.
-//
-// A "display" surface is one that is intended to be drawn to the
-// screen with gr_blit(). An "alpha" surface is a grayscale image
-// interpreted as an alpha mask used to render text in the current
-// color (with gr_text() or gr_texticon()).
-//
-// All these functions load PNG images from "/res/images/${name}.png".
-
-// Load a single display surface from a PNG image.
-int res_create_display_surface(const char* name, gr_surface* pSurface);
-
-// Load an array of display surfaces from a single PNG image. The PNG
-// should have a 'Frames' text chunk whose value is the number of
-// frames this image represents. The pixel data itself is interlaced
-// by row.
-int res_create_multi_display_surface(const char* name,
- int* frames, gr_surface** pSurface);
-
-// Load a single alpha surface from a grayscale PNG image.
-int res_create_alpha_surface(const char* name, gr_surface* pSurface);
-
-// Load part of a grayscale PNG image that is the first match for the
-// given locale. The image is expected to be a composite of multiple
-// translations of the same text, with special added rows that encode
-// the subimages' size and intended locale in the pixel data. See
-// development/tools/recovery_l10n for an app that will generate these
-// specialized images from Android resources.
-int res_create_localized_alpha_surface(const char* name, const char* locale,
- gr_surface* pSurface);
-
-// Free a surface allocated by any of the res_create_*_surface()
-// functions.
+// Returns 0 if no error, else negative.
+int res_create_surface(const char* name, gr_surface* pSurface);
+int res_create_localized_surface(const char* name, gr_surface* pSurface);
void res_free_surface(gr_surface surface);
static inline int res_create_display_surface(const char* name, gr_surface* pSurface) {
return res_create_surface(name, pSurface);
diff --git a/minui/resources.c b/minui/resources.c
index 92a3d316a..064325edf 100644
--- a/minui/resources.c
+++ b/minui/resources.c
@@ -27,6 +27,8 @@
#include <linux/fb.h>
#include <linux/kd.h>
+#include <pixelflinger/pixelflinger.h>
+
#include <png.h>
#include "minui.h"
@@ -37,22 +39,23 @@ char *locale = NULL;
extern char* locale;
#endif
-#define SURFACE_DATA_ALIGNMENT 8
-
-static gr_surface malloc_surface(size_t data_size) {
- unsigned char* temp = malloc(sizeof(GRSurface) + data_size + SURFACE_DATA_ALIGNMENT);
- if (temp == NULL) return NULL;
- gr_surface surface = (gr_surface) temp;
- surface->data = temp + sizeof(GRSurface) +
- (SURFACE_DATA_ALIGNMENT - (sizeof(GRSurface) % SURFACE_DATA_ALIGNMENT));
- return surface;
+// libpng gives "undefined reference to 'pow'" errors, and I have no
+// idea how to convince the build system to link with -lm. We don't
+// need this functionality (it's used for gamma adjustment) so provide
+// a dummy implementation to satisfy the linker.
+double pow(double x, double y) {
+ return x * y;
}
-static int open_png(const char* name, png_structp* png_ptr, png_infop* info_ptr,
- png_uint_32* width, png_uint_32* height, png_byte* channels) {
+int res_create_surface(const char* name, gr_surface* pSurface) {
char resPath[256];
- unsigned char header[8];
+ GGLSurface* surface = NULL;
int result = 0;
+ unsigned char header[8];
+ png_structp png_ptr = NULL;
+ png_infop info_ptr = NULL;
+
+ *pSurface = NULL;
snprintf(resPath, sizeof(resPath)-1, "/res/images/%s.png", name);
resPath[sizeof(resPath)-1] = '\0';
@@ -73,286 +76,117 @@ static int open_png(const char* name, png_structp* png_ptr, png_infop* info_ptr,
goto exit;
}
- *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
- if (!*png_ptr) {
+ png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+ if (!png_ptr) {
result = -4;
goto exit;
}
- *info_ptr = png_create_info_struct(*png_ptr);
- if (!*info_ptr) {
+ info_ptr = png_create_info_struct(png_ptr);
+ if (!info_ptr) {
result = -5;
goto exit;
}
- if (setjmp(png_jmpbuf(*png_ptr))) {
+ if (setjmp(png_jmpbuf(png_ptr))) {
result = -6;
goto exit;
}
- png_init_io(*png_ptr, fp);
- png_set_sig_bytes(*png_ptr, sizeof(header));
- png_read_info(*png_ptr, *info_ptr);
+ png_init_io(png_ptr, fp);
+ png_set_sig_bytes(png_ptr, sizeof(header));
+ png_read_info(png_ptr, info_ptr);
int color_type, bit_depth;
- png_get_IHDR(*png_ptr, *info_ptr, width, height, &bit_depth,
+ size_t width, height;
+
+ png_get_IHDR(png_ptr, info_ptr, width, height, &bit_depth,
&color_type, NULL, NULL, NULL);
- *channels = png_get_channels(*png_ptr, *info_ptr);
-
- if (bit_depth == 8 && *channels == 3 && color_type == PNG_COLOR_TYPE_RGB) {
- // 8-bit RGB images: great, nothing to do.
- } else if (bit_depth <= 8 && *channels == 1 && color_type == PNG_COLOR_TYPE_GRAY) {
- // 1-, 2-, 4-, or 8-bit gray images: expand to 8-bit gray.
- png_set_expand_gray_1_2_4_to_8(*png_ptr);
- } else if (bit_depth <= 8 && *channels == 1 && color_type == PNG_COLOR_TYPE_PALETTE) {
- // paletted images: expand to 8-bit RGB. Note that we DON'T
- // currently expand the tRNS chunk (if any) to an alpha
- // channel, because minui doesn't support alpha channels in
- // general.
- png_set_palette_to_rgb(*png_ptr);
- *channels = 3;
- } else {
- fprintf(stderr, "minui doesn't support PNG depth %d channels %d color_type %d\n",
- bit_depth, *channels, color_type);
- result = -7;
+ png_byte* channels = png_get_channels(png_ptr, info_ptr);
+
+ if (!(bit_depth == 8 &&
+ ((channels == 3 && color_type == PNG_COLOR_TYPE_RGB) ||
+ (channels == 4 && color_type == PNG_COLOR_TYPE_RGBA) ||
+ (channels == 1 && (color_type == PNG_COLOR_TYPE_PALETTE ||
+ color_type == PNG_COLOR_TYPE_GRAY))))) {
+ return -7;
goto exit;
}
- return result;
+ size_t stride = (color_type == PNG_COLOR_TYPE_GRAY ? 1 : 4) * width;
+ size_t pixelSize = stride * height;
- exit:
- if (result < 0) {
- png_destroy_read_struct(png_ptr, info_ptr, NULL);
- }
- if (fp != NULL) {
- fclose(fp);
+ surface = malloc(sizeof(GGLSurface) + pixelSize);
+ if (surface == NULL) {
+ result = -8;
+ goto exit;
}
-
- return result;
-}
-
-// "display" surfaces are transformed into the framebuffer's required
-// pixel format (currently only RGBX is supported) at load time, so
-// gr_blit() can be nothing more than a memcpy() for each row. The
-// next two functions are the only ones that know anything about the
-// framebuffer pixel format; they need to be modified if the
-// framebuffer format changes (but nothing else should).
-
-// Allocate and return a gr_surface sufficient for storing an image of
-// the indicated size in the framebuffer pixel format.
-static gr_surface init_display_surface(png_uint_32 width, png_uint_32 height) {
- gr_surface surface;
-
- surface = malloc_surface(width * height * 4);
- if (surface == NULL) return NULL;
-
+ unsigned char* pData = (unsigned char*) (surface + 1);
+ surface->version = sizeof(GGLSurface);
surface->width = width;
surface->height = height;
- surface->row_bytes = width * 4;
- surface->pixel_bytes = 4;
-
- return surface;
-}
-
-// Copy 'input_row' to 'output_row', transforming it to the
-// framebuffer pixel format. The input format depends on the value of
-// 'channels':
-//
-// 1 - input is 8-bit grayscale
-// 3 - input is 24-bit RGB
-// 4 - input is 32-bit RGBA/RGBX
-//
-// 'width' is the number of pixels in the row.
-static void transform_rgb_to_draw(unsigned char* input_row,
- unsigned char* output_row,
- int channels, int width) {
- int x;
- unsigned char* ip = input_row;
- unsigned char* op = output_row;
-
- switch (channels) {
- case 1:
- // expand gray level to RGBX
- for (x = 0; x < width; ++x) {
- *op++ = *ip;
- *op++ = *ip;
- *op++ = *ip;
- *op++ = 0xff;
- ip++;
- }
- break;
-
- case 3:
- // expand RGBA to RGBX
- for (x = 0; x < width; ++x) {
- *op++ = *ip++;
- *op++ = *ip++;
- *op++ = *ip++;
- *op++ = 0xff;
- }
- break;
-
- case 4:
- // copy RGBA to RGBX
- memcpy(output_row, input_row, width*4);
- break;
+ surface->stride = width; /* Yes, pixels, not bytes */
+ surface->data = pData;
+ surface->format = (channels == 3) ? GGL_PIXEL_FORMAT_RGBX_8888 :
+ ((color_type == PNG_COLOR_TYPE_PALETTE ? GGL_PIXEL_FORMAT_RGBA_8888 : GGL_PIXEL_FORMAT_L_8));
+
+ int alpha = 0;
+ if (color_type == PNG_COLOR_TYPE_PALETTE) {
+ png_set_palette_to_rgb(png_ptr);
}
-}
-
-int res_create_display_surface(const char* name, gr_surface* pSurface) {
- gr_surface surface = NULL;
- int result = 0;
- png_structp png_ptr = NULL;
- png_infop info_ptr = NULL;
- png_uint_32 width, height;
- png_byte channels;
-
- *pSurface = NULL;
-
- result = open_png(name, &png_ptr, &info_ptr, &width, &height, &channels);
- if (result < 0) return result;
-
- surface = init_display_surface(width, height);
- if (surface == NULL) {
- result = -8;
- goto exit;
+ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
+ png_set_tRNS_to_alpha(png_ptr);
+ alpha = 1;
}
-
- unsigned char* p_row = malloc(width * 4);
- unsigned int y;
- for (y = 0; y < height; ++y) {
- png_read_row(png_ptr, p_row, NULL);
- transform_rgb_to_draw(p_row, surface->data + y * surface->row_bytes, channels, width);
+ if (color_type == PNG_COLOR_TYPE_GRAY) {
+ alpha = 1;
}
- free(p_row);
-
- *pSurface = surface;
-
- exit:
- png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
- if (result < 0 && surface != NULL) free(surface);
- return result;
-}
-
-int res_create_multi_display_surface(const char* name, int* frames, gr_surface** pSurface) {
- gr_surface* surface = NULL;
- int result = 0;
- png_structp png_ptr = NULL;
- png_infop info_ptr = NULL;
- png_uint_32 width, height;
- png_byte channels;
- int i;
- *pSurface = NULL;
- *frames = -1;
-
- result = open_png(name, &png_ptr, &info_ptr, &width, &height, &channels);
- if (result < 0) return result;
-
- *frames = 1;
- png_textp text;
- int num_text;
- if (png_get_text(png_ptr, info_ptr, &text, &num_text)) {
- for (i = 0; i < num_text; ++i) {
- if (text[i].key && strcmp(text[i].key, "Frames") == 0 && text[i].text) {
- *frames = atoi(text[i].text);
- break;
+ unsigned int y;
+ if (channels == 3 || (channels == 1 && !alpha)) {
+ for (y = 0; y < height; ++y) {
+ unsigned char* pRow = pData + y * stride;
+ png_read_row(png_ptr, pRow, NULL);
+
+ int x;
+ for(x = width - 1; x >= 0; x--) {
+ int sx = x * 3;
+ int dx = x * 4;
+ unsigned char r = pRow[sx];
+ unsigned char g = pRow[sx + 1];
+ unsigned char b = pRow[sx + 2];
+ unsigned char a = 0xff;
+ pRow[dx ] = r; // r
+ pRow[dx + 1] = g; // g
+ pRow[dx + 2] = b; // b
+ pRow[dx + 3] = a;
}
}
- printf(" found frames = %d\n", *frames);
- }
-
- if (height % *frames != 0) {
- printf("bad height (%d) for frame count (%d)\n", height, *frames);
- result = -9;
- goto exit;
- }
-
- surface = malloc(*frames * sizeof(gr_surface));
- if (surface == NULL) {
- result = -8;
- goto exit;
- }
- for (i = 0; i < *frames; ++i) {
- surface[i] = init_display_surface(width, height / *frames);
- if (surface[i] == NULL) {
- result = -8;
- goto exit;
+ } else {
+ for (y = 0; y < height; ++y) {
+ unsigned char* pRow = pData + y * stride;
+ png_read_row(png_ptr, pRow, NULL);
}
}
- unsigned char* p_row = malloc(width * 4);
- unsigned int y;
- for (y = 0; y < height; ++y) {
- png_read_row(png_ptr, p_row, NULL);
- int frame = y % *frames;
- unsigned char* out_row = surface[frame]->data +
- (y / *frames) * surface[frame]->row_bytes;
- transform_rgb_to_draw(p_row, out_row, channels, width);
- }
- free(p_row);
-
- *pSurface = (gr_surface*) surface;
+ *pSurface = (gr_surface) surface;
exit:
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+ if (fp != NULL) {
+ fclose(fp);
+ }
if (result < 0) {
if (surface) {
- for (i = 0; i < *frames; ++i) {
- if (surface[i]) free(surface[i]);
- }
free(surface);
}
}
return result;
}
-int res_create_alpha_surface(const char* name, gr_surface* pSurface) {
- gr_surface surface = NULL;
- int result = 0;
- png_structp png_ptr = NULL;
- png_infop info_ptr = NULL;
- png_uint_32 width, height;
- png_byte channels;
-
- *pSurface = NULL;
-
- result = open_png(name, &png_ptr, &info_ptr, &width, &height, &channels);
- if (result < 0) return result;
-
- if (channels != 1) {
- result = -7;
- goto exit;
- }
-
- surface = malloc_surface(width * height);
- if (surface == NULL) {
- result = -8;
- goto exit;
- }
- surface->width = width;
- surface->height = height;
- surface->row_bytes = width;
- surface->pixel_bytes = 1;
-
- unsigned char* p_row;
- unsigned int y;
- for (y = 0; y < height; ++y) {
- p_row = surface->data + y * surface->row_bytes;
- png_read_row(png_ptr, p_row, NULL);
- }
-
- *pSurface = surface;
-
- exit:
- png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
- if (result < 0 && surface != NULL) free(surface);
- return result;
-}
-
-static int matches_locale(const char* loc, const char* locale) {
+static int matches_locale(const char* loc) {
if (locale == NULL) return 0;
if (strcmp(loc, locale) == 0) return 1;
@@ -369,61 +203,101 @@ static int matches_locale(const char* loc, const char* locale) {
return (strncmp(locale, loc, i) == 0 && locale[i] == '_');
}
-int res_create_localized_alpha_surface(const char* name,
- const char* locale,
- gr_surface* pSurface) {
- gr_surface surface = NULL;
+int res_create_localized_surface(const char* name, gr_surface* pSurface) {
+ char resPath[256];
+ GGLSurface* surface = NULL;
int result = 0;
+ unsigned char header[8];
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
- png_uint_32 width, height;
- png_byte channels;
*pSurface = NULL;
- if (locale == NULL) {
- surface = malloc_surface(0);
- surface->width = 0;
- surface->height = 0;
- surface->row_bytes = 0;
- surface->pixel_bytes = 1;
+ snprintf(resPath, sizeof(resPath)-1, "/res/images/%s.png", name);
+ resPath[sizeof(resPath)-1] = '\0';
+ FILE* fp = fopen(resPath, "rb");
+ if (fp == NULL) {
+ result = -1;
+ goto exit;
+ }
+
+ size_t bytesRead = fread(header, 1, sizeof(header), fp);
+ if (bytesRead != sizeof(header)) {
+ result = -2;
+ goto exit;
+ }
+
+ if (png_sig_cmp(header, 0, sizeof(header))) {
+ result = -3;
+ goto exit;
+ }
+
+ png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+ if (!png_ptr) {
+ result = -4;
+ goto exit;
+ }
+
+ info_ptr = png_create_info_struct(png_ptr);
+ if (!info_ptr) {
+ result = -5;
+ goto exit;
+ }
+
+ if (setjmp(png_jmpbuf(png_ptr))) {
+ result = -6;
goto exit;
}
- result = open_png(name, &png_ptr, &info_ptr, &width, &height, &channels);
- if (result < 0) return result;
+ png_init_io(png_ptr, fp);
+ png_set_sig_bytes(png_ptr, sizeof(header));
+ png_read_info(png_ptr, info_ptr);
+
+ int color_type, bit_depth;
+ size_t width, height;
+
+ png_get_IHDR(png_ptr, info_ptr, width, height, &bit_depth,
+ &color_type, NULL, NULL, NULL);
+
+ png_byte* channels = png_get_channels(png_ptr, info_ptr);
+ size_t stride = 4 * width;
- if (channels != 1) {
- result = -7;
+ if (!(bit_depth == 8 &&
+ (channels == 1 && color_type == PNG_COLOR_TYPE_GRAY))) {
+ return -7;
goto exit;
}
unsigned char* row = malloc(width);
- png_uint_32 y;
+ int y;
for (y = 0; y < height; ++y) {
png_read_row(png_ptr, row, NULL);
int w = (row[1] << 8) | row[0];
int h = (row[3] << 8) | row[2];
int len = row[4];
- char* loc = (char*)row+5;
+ char* loc = row+5;
- if (y+1+h >= height || matches_locale(loc, locale)) {
+ if (y+1+h >= height || matches_locale(loc)) {
printf(" %20s: %s (%d x %d @ %d)\n", name, loc, w, h, y);
- surface = malloc_surface(w*h);
+ surface = malloc(sizeof(GGLSurface));
if (surface == NULL) {
result = -8;
goto exit;
}
+ unsigned char* pData = malloc(w*h);
+
+ surface->version = sizeof(GGLSurface);
surface->width = w;
surface->height = h;
- surface->row_bytes = w;
- surface->pixel_bytes = 1;
+ surface->stride = w; /* Yes, pixels, not bytes */
+ surface->data = pData;
+ surface->format = GGL_PIXEL_FORMAT_A_8;
int i;
for (i = 0; i < h; ++i, ++y) {
png_read_row(png_ptr, row, NULL);
- memcpy(surface->data + i*w, row, w);
+ memcpy(pData + i*w, row, w);
}
*pSurface = (gr_surface) surface;
@@ -438,10 +312,21 @@ int res_create_localized_alpha_surface(const char* name,
exit:
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
- if (result < 0 && surface != NULL) free(surface);
+
+ if (fp != NULL) {
+ fclose(fp);
+ }
+ if (result < 0) {
+ if (surface) {
+ free(surface);
+ }
+ }
return result;
}
void res_free_surface(gr_surface surface) {
- free(surface);
+ GGLSurface* pSurface = (GGLSurface*) surface;
+ if (pSurface) {
+ free(pSurface);
+ }
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 23:53:03 +0100