From a33161b02020d34baf210c2bd89201564d6d99f6 Mon Sep 17 00:00:00 2001 From: Ethan Yonker Date: Thu, 6 Nov 2014 15:11:20 -0600 Subject: Revert to old libminui and fix up We will wait for CAF to give us a new libminui that supports qualcomm overlay before moving up to the new format if possible. Attempt to fix up old libminui to work with new libpng. Change-Id: I494b7287b347f4730aa8f9d27d4cc17b6e93919a --- minui/Android.mk | 7 +- minui/events.c | 86 +++------- minui/font_10x18.h | 2 +- minui/graphics.c | 333 +++++++++++--------------------------- minui/graphics.h | 50 ------ minui/graphics_adf.c | 247 ---------------------------- minui/graphics_fbdev.c | 217 ------------------------- minui/minui.h | 60 ++----- minui/resources.c | 431 ++++++++++++++++++------------------------------- 9 files changed, 292 insertions(+), 1141 deletions(-) delete mode 100644 minui/graphics.h delete mode 100644 minui/graphics_adf.c delete mode 100644 minui/graphics_fbdev.c (limited to 'minui') 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 #include #include -#include +#include #include @@ -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 #include -#include +#include #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 -#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 -#include -#include -#include -#include -#include - -#include -#include - -#include - -#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 -#include -#include - -#include -#include - -#include -#include -#include -#include - -#include -#include - -#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 - #include #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 #include +#include + #include #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); + } } -- cgit v1.2.3