tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

remove pixelflinger from recovery

Browse source 
Recovery now draws directly to the framebuffer by rolling its own
graphics code, rather than depending on libpixelflinger.

The recovery UI is modified slightly to eliminate operations that are
slow with the software implementation: when the text display / menu is
turned on, it now appears on a black background instead of a dimmed
version of the recovery icon.

There's probably substantial room for optimization of the graphics
operations.

Bug: 12131110
Change-Id: Iab6520e0a7aaec39e2ce39377c10aef82ae0c595
This commit is contained in:
Doug Zongker 2014-03-06 16:16:05 -08:00
parent eac881c952
commit 39cf417e17
6 changed files with 362 additions and 286 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Android.mk
View file

@ -46,7 +46,6 @@ LOCAL_STATIC_LIBRARIES := \
libmincrypt \ libmincrypt \
libminadbd \ libminadbd \
libminui \ libminui \
libpixelflinger_static \
libpng \ libpng \
libfs_mgr \ libfs_mgr \
libcutils \ libcutils \

509
minui/graphics.c
View file

@ -28,37 +28,19 @@
#include <linux/fb.h> #include <linux/fb.h>
#include <linux/kd.h> #include <linux/kd.h>
#include <pixelflinger/pixelflinger.h> #include <time.h>
#include "font_10x18.h" #include "font_10x18.h"
#include "minui.h" #include "minui.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 { typedef struct {
GGLSurface* texture; GRSurface* texture;
unsigned cwidth; int cwidth;
unsigned cheight; int cheight;
} GRFont; } GRFont;
static GRFont *gr_font = 0; static GRFont* gr_font = NULL;
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_percent = OVERSCAN_PERCENT;
static int overscan_offset_x = 0; static int overscan_offset_x = 0;
static int overscan_offset_y = 0; static int overscan_offset_y = 0;
@ -66,66 +48,81 @@ static int overscan_offset_y = 0;
static int gr_fb_fd = -1; static int gr_fb_fd = -1;
static int gr_vt_fd = -1; static int gr_vt_fd = -1;
static struct fb_var_screeninfo vi; static GRSurface gr_framebuffer[2];
static struct fb_fix_screeninfo fi; static bool double_buffered;
static GRSurface* gr_draw = NULL;
static int displayed_buffer;
static int get_framebuffer(GGLSurface *fb) 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 struct fb_var_screeninfo vi;
static bool outside(int x, int y)
{
return x < 0 || x >= gr_draw->width || y < 0 || y >= gr_draw->height;
}
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(gr_fb_fd, FBIOPUT_VSCREENINFO, &vi) < 0) {
perror("active fb swap failed");
}
displayed_buffer = n;
}
static int get_framebuffer()
{ {
int fd; int fd;
void *bits; void *bits;
struct fb_fix_screeninfo fi;
fd = open("/dev/graphics/fb0", O_RDWR); fd = open("/dev/graphics/fb0", O_RDWR);
if (fd < 0) { if (fd < 0) {
perror("cannot open fb0"); perror("cannot open fb0");
return -1; return -1;
} }
if (ioctl(fd, FBIOGET_FSCREENINFO, &fi) < 0) {
perror("failed to get fb0 info");
close(fd);
return -1;
}
if (ioctl(fd, FBIOGET_VSCREENINFO, &vi) < 0) { if (ioctl(fd, FBIOGET_VSCREENINFO, &vi) < 0) {
perror("failed to get fb0 info"); perror("failed to get fb0 info");
close(fd); close(fd);
return -1; return -1;
} }
vi.bits_per_pixel = PIXEL_SIZE * 8; // We print this out for informational purposes only, but
if (PIXEL_FORMAT == GGL_PIXEL_FORMAT_BGRA_8888) { // throughout we assume that the framebuffer device uses an RGBX
vi.red.offset = 8; // pixel format. This is the case for every development device I
vi.red.length = 8; // have access to. For some of those devices (eg, hammerhead aka
vi.green.offset = 16; // Nexus 5), FBIOGET_VSCREENINFO *reports* that it wants a
vi.green.length = 8; // different format (XBGR) but actually produces the correct
vi.blue.offset = 24; // results on the display when you write RGBX.
vi.blue.length = 8; //
vi.transp.offset = 0; // If you have a device that actually *needs* another pixel format
vi.transp.length = 8; // (ie, BGRX, or 565), patches welcome...
} else if (PIXEL_FORMAT == GGL_PIXEL_FORMAT_RGBX_8888) {
vi.red.offset = 24;
vi.red.length = 8;
vi.green.offset = 16;
vi.green.length = 8;
vi.blue.offset = 8;
vi.blue.length = 8;
vi.transp.offset = 0;
vi.transp.length = 8;
} else { /* RGB565*/
vi.red.offset = 11;
vi.red.length = 5;
vi.green.offset = 5;
vi.green.length = 6;
vi.blue.offset = 0;
vi.blue.length = 5;
vi.transp.offset = 0;
vi.transp.length = 0;
}
if (ioctl(fd, FBIOPUT_VSCREENINFO, &vi) < 0) {
perror("failed to put fb0 info");
close(fd);
return -1;
}
if (ioctl(fd, FBIOGET_FSCREENINFO, &fi) < 0) { printf("fb0 reports (possibly inaccurate):\n"
perror("failed to get fb0 info"); " vi.bits_per_pixel = %d\n"
close(fd); " vi.red.offset = %3d .length = %3d\n"
return -1; " 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); bits = mmap(0, fi.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (bits == MAP_FAILED) { if (bits == MAP_FAILED) {
@ -137,79 +134,59 @@ static int get_framebuffer(GGLSurface *fb)
overscan_offset_x = vi.xres * overscan_percent / 100; overscan_offset_x = vi.xres * overscan_percent / 100;
overscan_offset_y = vi.yres * overscan_percent / 100; overscan_offset_y = vi.yres * overscan_percent / 100;
fb->version = sizeof(*fb); gr_framebuffer[0].width = vi.xres;
fb->width = vi.xres; gr_framebuffer[0].height = vi.yres;
fb->height = vi.yres; gr_framebuffer[0].row_bytes = fi.line_length;
fb->stride = fi.line_length/PIXEL_SIZE; gr_framebuffer[0].pixel_bytes = vi.bits_per_pixel / 8;
fb->data = bits; gr_framebuffer[0].data = bits;
fb->format = PIXEL_FORMAT; memset(gr_framebuffer[0].data, 0, gr_framebuffer[0].height * gr_framebuffer[0].row_bytes);
memset(fb->data, 0, vi.yres * fi.line_length);
fb++;
/* check if we can use double buffering */ /* check if we can use double buffering */
if (vi.yres * fi.line_length * 2 > fi.smem_len) if (vi.yres * fi.line_length * 2 <= fi.smem_len) {
return fd; double_buffered = true;
double_buffering = 1; 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;
fb->version = sizeof(*fb); gr_draw = gr_framebuffer+1;
fb->width = vi.xres;
fb->height = vi.yres; } else {
fb->stride = fi.line_length/PIXEL_SIZE; double_buffered = false;
fb->data = (void*) (((char*) bits) + vi.yres * fi.line_length);
fb->format = PIXEL_FORMAT; // Without double-buffering, we allocate RAM for a buffer to
memset(fb->data, 0, vi.yres * fi.line_length); // 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 -1;
}
}
memset(gr_draw->data, 0, gr_draw->height * gr_draw->row_bytes);
gr_fb_fd = fd;
set_displayed_framebuffer(0);
return fd; return fd;
} }
static void get_memory_surface(GGLSurface* ms) {
ms->version = sizeof(*ms);
ms->width = vi.xres;
ms->height = vi.yres;
ms->stride = fi.line_length/PIXEL_SIZE;
ms->data = malloc(fi.line_length * vi.yres);
ms->format = PIXEL_FORMAT;
}
static void set_active_framebuffer(unsigned n)
{
if (n > 1 || !double_buffering) return;
vi.yres_virtual = vi.yres * NUM_BUFFERS;
vi.yoffset = n * vi.yres;
vi.bits_per_pixel = PIXEL_SIZE * 8;
if (ioctl(gr_fb_fd, FBIOPUT_VSCREENINFO, &vi) < 0) {
perror("active fb swap failed");
}
}
void gr_flip(void) void gr_flip(void)
{ {
GGLContext *gl = gr_context; if (double_buffered) {
// Change gr_draw to point to the buffer currently displayed,
/* swap front and back buffers */ // then flip the driver so we're displaying the other buffer
if (double_buffering) // instead.
gr_active_fb = (gr_active_fb + 1) & 1; gr_draw = gr_framebuffer + displayed_buffer;
set_displayed_framebuffer(1-displayed_buffer);
/* copy data from the in-memory surface to the buffer we're about } else {
* to make active. */ // Copy from the in-memory surface to the framebuffer.
memcpy(gr_framebuffer[gr_active_fb].data, gr_mem_surface.data, memcpy(gr_framebuffer[0].data, gr_draw->data,
fi.line_length * vi.yres); gr_draw->height * gr_draw->row_bytes);
}
/* inform the display driver */
set_active_framebuffer(gr_active_fb);
}
void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
GGLContext *gl = gr_context;
GGLint color[4];
color[0] = ((r << 8) | r) + 1;
color[1] = ((g << 8) | g) + 1;
color[2] = ((b << 8) | b) + 1;
color[3] = ((a << 8) | a) + 1;
gl->color4xv(gl, color);
} }
int gr_measure(const char *s) int gr_measure(const char *s)
@ -223,58 +200,118 @@ void gr_font_size(int *x, int *y)
*y = gr_font->cheight; *y = gr_font->cheight;
} }
int gr_text(int x, int y, const char *s, int bold) 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;
}
}
void gr_text(int x, int y, const char *s, int bold)
{ {
GGLContext *gl = gr_context;
GRFont *font = gr_font; GRFont *font = gr_font;
unsigned off; unsigned off;
if (!font->texture) return x; if (!font->texture) return;
if (gr_current_a == 0) return;
bold = bold && (font->texture->height != font->cheight); bold = bold && (font->texture->height != font->cheight);
x += overscan_offset_x; x += overscan_offset_x;
y += overscan_offset_y; 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++)) { while((off = *s++)) {
off -= 32; off -= 32;
if (outside(x, y) || outside(x+font->cwidth-1, y+font->cheight-1)) break;
if (off < 96) { if (off < 96) {
gl->texCoord2i(gl, (off * font->cwidth) - x,
(bold ? font->cheight : 0) - y); unsigned char* src_p = font->texture->data + (off * font->cwidth) +
gl->recti(gl, x, y, x + font->cwidth, y + font->cheight); (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);
} }
x += font->cwidth; x += font->cwidth;
} }
return x;
} }
void gr_texticon(int x, int y, gr_surface icon) { void gr_texticon(int x, int y, GRSurface* icon) {
if (gr_context == NULL || icon == NULL) { if (icon == NULL) return;
if (icon->pixel_bytes != 1) {
printf("gr_texticon: source has wrong format\n");
return; return;
} }
GGLContext* gl = gr_context;
x += overscan_offset_x; x += overscan_offset_x;
y += overscan_offset_y; y += overscan_offset_y;
gl->bindTexture(gl, (GGLSurface*) icon); if (outside(x, y) || outside(x+icon->width-1, y+icon->height-1)) return;
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);
int w = gr_get_width(icon); unsigned char* src_p = icon->data;
int h = gr_get_height(icon); unsigned char* dst_p = gr_draw->data + y*gr_draw->row_bytes + x*gr_draw->pixel_bytes;
gl->texCoord2i(gl, -x, -y); text_blend(src_p, icon->row_bytes,
gl->recti(gl, x, y, x+gr_get_width(icon), y+gr_get_height(icon)); 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);
}
}
} }
void gr_fill(int x1, int y1, int x2, int y2) void gr_fill(int x1, int y1, int x2, int y2)
@ -285,48 +322,82 @@ void gr_fill(int x1, int y1, int x2, int y2)
x2 += overscan_offset_x; x2 += overscan_offset_x;
y2 += overscan_offset_y; y2 += overscan_offset_y;
GGLContext *gl = gr_context; if (outside(x1, y1) || outside(x2-1, y2-1)) return;
gl->disable(gl, GGL_TEXTURE_2D);
gl->recti(gl, x1, y1, x2, y2); 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;
}
}
} }
void gr_blit(gr_surface source, int sx, int sy, int w, int h, int dx, int dy) { void gr_blit(GRSurface* source, int sx, int sy, int w, int h, int dx, int dy) {
if (gr_context == NULL || source == NULL) { if (source == NULL) return;
if (gr_draw->pixel_bytes != source->pixel_bytes) {
printf("gr_blit: source has wrong format\n");
return; return;
} }
GGLContext *gl = gr_context;
dx += overscan_offset_x; dx += overscan_offset_x;
dy += overscan_offset_y; dy += overscan_offset_y;
gl->bindTexture(gl, (GGLSurface*) source); if (outside(dx, dy) || outside(dx+w-1, dy+h-1)) return;
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); unsigned char* src_p = source->data + sy*source->row_bytes + sx*source->pixel_bytes;
gl->texGeni(gl, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE); unsigned char* dst_p = gr_draw->data + dy*gr_draw->row_bytes + dx*gr_draw->pixel_bytes;
gl->enable(gl, GGL_TEXTURE_2D);
gl->texCoord2i(gl, sx - dx, sy - dy); int i;
gl->recti(gl, dx, dy, dx + w, dy + h); 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;
}
} }
unsigned int gr_get_width(gr_surface surface) { unsigned int gr_get_width(GRSurface* surface) {
if (surface == NULL) { if (surface == NULL) {
return 0; return 0;
} }
return ((GGLSurface*) surface)->width; return surface->width;
} }
unsigned int gr_get_height(gr_surface surface) { unsigned int gr_get_height(GRSurface* surface) {
if (surface == NULL) { if (surface == NULL) {
return 0; return 0;
} }
return ((GGLSurface*) surface)->height; return surface->height;
} }
static void gr_init_font(void) static void gr_init_font(void)
{ {
gr_font = calloc(sizeof(*gr_font), 1); gr_font = calloc(sizeof(*gr_font), 1);
int res = res_create_surface("font", (void**)&(gr_font->texture)); int res = res_create_surface("font", &(gr_font->texture));
if (res == 0) { if (res == 0) {
// The font image should be a 96x2 array of character images. The // The font image should be a 96x2 array of character images. The
// columns are the printable ASCII characters 0x20 - 0x7f. The // columns are the printable ASCII characters 0x20 - 0x7f. The
@ -340,7 +411,8 @@ static void gr_init_font(void)
gr_font->texture = malloc(sizeof(*gr_font->texture)); gr_font->texture = malloc(sizeof(*gr_font->texture));
gr_font->texture->width = font.width; gr_font->texture->width = font.width;
gr_font->texture->height = font.height; gr_font->texture->height = font.height;
gr_font->texture->stride = font.width; gr_font->texture->row_bytes = font.width;
gr_font->texture->pixel_bytes = 1;
unsigned char* bits = malloc(font.width * font.height); unsigned char* bits = malloc(font.width * font.height);
gr_font->texture->data = (void*) bits; gr_font->texture->data = (void*) bits;
@ -355,17 +427,61 @@ static void gr_init_font(void)
gr_font->cwidth = font.cwidth; gr_font->cwidth = font.cwidth;
gr_font->cheight = font.cheight; gr_font->cheight = font.cheight;
} }
// interpret the grayscale as alpha
gr_font->texture->format = GGL_PIXEL_FORMAT_A_8;
} }
#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_flip();
}
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
int gr_init(void) int gr_init(void)
{ {
gglInit(&gr_context);
GGLContext *gl = gr_context;
gr_init_font(); gr_init_font();
gr_vt_fd = open("/dev/tty0", O_RDWR | O_SYNC); gr_vt_fd = open("/dev/tty0", O_RDWR | O_SYNC);
if (gr_vt_fd < 0) { if (gr_vt_fd < 0) {
// This is non-fatal; post-Cupcake kernels don't have tty0. // This is non-fatal; post-Cupcake kernels don't have tty0.
@ -377,25 +493,16 @@ int gr_init(void)
return -1; return -1;
} }
gr_fb_fd = get_framebuffer(gr_framebuffer); if (get_framebuffer(&gr_framebuffer) < 0) {
if (gr_fb_fd < 0) {
gr_exit(); gr_exit();
return -1; return -1;
} }
get_memory_surface(&gr_mem_surface);
printf("framebuffer: fd %d (%d x %d)\n", printf("framebuffer: fd %d (%d x %d)\n",
gr_fb_fd, gr_framebuffer[0].width, gr_framebuffer[0].height); gr_fb_fd, gr_draw->width, gr_draw->height);
/* start with 0 as front (displayed) and 1 as back (drawing) */ gr_flip();
gr_active_fb = 0; gr_flip();
set_active_framebuffer(0);
gl->colorBuffer(gl, &gr_mem_surface);
gl->activeTexture(gl, 0);
gl->enable(gl, GGL_BLEND);
gl->blendFunc(gl, GGL_SRC_ALPHA, GGL_ONE_MINUS_SRC_ALPHA);
gr_fb_blank(true); gr_fb_blank(true);
gr_fb_blank(false); gr_fb_blank(false);
@ -408,26 +515,24 @@ void gr_exit(void)
close(gr_fb_fd); close(gr_fb_fd);
gr_fb_fd = -1; gr_fb_fd = -1;
free(gr_mem_surface.data);
ioctl(gr_vt_fd, KDSETMODE, (void*) KD_TEXT); ioctl(gr_vt_fd, KDSETMODE, (void*) KD_TEXT);
close(gr_vt_fd); close(gr_vt_fd);
gr_vt_fd = -1; gr_vt_fd = -1;
if (!double_buffered) {
if (gr_draw) free(gr_draw->data);
free(gr_draw);
}
} }
int gr_fb_width(void) int gr_fb_width(void)
{ {
return gr_framebuffer[0].width - 2*overscan_offset_x; return gr_draw->width - 2*overscan_offset_x;
} }
int gr_fb_height(void) int gr_fb_height(void)
{ {
return gr_framebuffer[0].height - 2*overscan_offset_y; return gr_draw->height - 2*overscan_offset_y;
}
gr_pixel *gr_fb_data(void)
{
return (unsigned short *) gr_mem_surface.data;
} }
void gr_fb_blank(bool blank) void gr_fb_blank(bool blank)

18
minui/minui.h
View file

@ -23,22 +23,30 @@
extern "C" { extern "C" {
#endif #endif
typedef void* gr_surface; typedef struct {
typedef unsigned short gr_pixel; int width;
int height;
int row_bytes;
int pixel_bytes;
unsigned char* data;
} GRSurface;
typedef GRSurface* gr_surface;
int gr_init(void); int gr_init(void);
void gr_exit(void); void gr_exit(void);
int gr_fb_width(void); int gr_fb_width(void);
int gr_fb_height(void); int gr_fb_height(void);
gr_pixel *gr_fb_data(void);
void gr_flip(void); void gr_flip(void);
void gr_fb_blank(bool blank); 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_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
void gr_fill(int x1, int y1, int x2, int y2); void gr_fill(int x1, int y1, int x2, int y2);
int gr_text(int x, int y, const char *s, int bold); void gr_text(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); int gr_measure(const char *s);
void gr_font_size(int *x, int *y); void gr_font_size(int *x, int *y);

103
minui/resources.c
View file

@ -27,25 +27,26 @@
#include <linux/fb.h> #include <linux/fb.h>
#include <linux/kd.h> #include <linux/kd.h>
#include <pixelflinger/pixelflinger.h>
#include <png.h> #include <png.h>
#include "minui.h" #include "minui.h"
extern char* locale; extern char* locale;
// libpng gives "undefined reference to 'pow'" errors, and I have no #define SURFACE_DATA_ALIGNMENT 8
// 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 static gr_surface malloc_surface(size_t data_size) {
// a dummy implementation to satisfy the linker. unsigned char* temp = malloc(sizeof(GRSurface) + data_size + SURFACE_DATA_ALIGNMENT);
double pow(double x, double y) { if (temp == NULL) return NULL;
return x * y; gr_surface surface = (gr_surface) temp;
surface->data = temp + sizeof(GRSurface) +
(SURFACE_DATA_ALIGNMENT - (sizeof(GRSurface) % SURFACE_DATA_ALIGNMENT));
return surface;
} }
int res_create_surface(const char* name, gr_surface* pSurface) { int res_create_surface(const char* name, gr_surface* pSurface) {
char resPath[256]; char resPath[256];
GGLSurface* surface = NULL; gr_surface surface = NULL;
int result = 0; int result = 0;
unsigned char header[8]; unsigned char header[8];
png_structp png_ptr = NULL; png_structp png_ptr = NULL;
@ -100,9 +101,8 @@ int res_create_surface(const char* name, gr_surface* pSurface) {
int channels = png_get_channels(png_ptr, info_ptr); int channels = png_get_channels(png_ptr, info_ptr);
if (!(bit_depth == 8 && if (!(bit_depth <= 8 &&
((channels == 3 && color_type == PNG_COLOR_TYPE_RGB) || ((channels == 3 && color_type == PNG_COLOR_TYPE_RGB) ||
(channels == 4 && color_type == PNG_COLOR_TYPE_RGBA) ||
(channels == 1 && (color_type == PNG_COLOR_TYPE_PALETTE || (channels == 1 && (color_type == PNG_COLOR_TYPE_PALETTE ||
color_type == PNG_COLOR_TYPE_GRAY))))) { color_type == PNG_COLOR_TYPE_GRAY))))) {
return -7; return -7;
@ -110,38 +110,20 @@ int res_create_surface(const char* name, gr_surface* pSurface) {
} }
size_t stride = (color_type == PNG_COLOR_TYPE_GRAY ? 1 : 4) * width; size_t stride = (color_type == PNG_COLOR_TYPE_GRAY ? 1 : 4) * width;
size_t pixelSize = stride * height;
surface = malloc(sizeof(GGLSurface) + pixelSize); surface = malloc_surface(stride * height);
if (surface == NULL) { if (surface == NULL) {
result = -8; result = -8;
goto exit; goto exit;
} }
unsigned char* pData = (unsigned char*) (surface + 1); unsigned char* pData = surface->data;
surface->version = sizeof(GGLSurface);
surface->width = width; surface->width = width;
surface->height = height; surface->height = height;
surface->stride = width; /* Yes, pixels, not bytes */ surface->row_bytes = stride;
surface->data = pData; surface->pixel_bytes = (color_type == PNG_COLOR_TYPE_GRAY ? 1 : 4);
if (channels == 3) {
surface->format = GGL_PIXEL_FORMAT_RGBX_8888;
} else if (color_type == PNG_COLOR_TYPE_PALETTE) {
surface->format = GGL_PIXEL_FORMAT_RGBA_8888;
} else if (channels == 1) {
surface->format = GGL_PIXEL_FORMAT_L_8;
} else {
surface->format = GGL_PIXEL_FORMAT_RGBA_8888;
}
int alpha = (channels == 4); int alpha = (channels == 4);
if (color_type == PNG_COLOR_TYPE_PALETTE) { png_set_expand(png_ptr);
png_set_palette_to_rgb(png_ptr);
}
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
png_set_tRNS_to_alpha(png_ptr);
alpha = 1;
}
if (color_type == PNG_COLOR_TYPE_GRAY) { if (color_type == PNG_COLOR_TYPE_GRAY) {
alpha = 1; alpha = 1;
} }
@ -196,7 +178,7 @@ int res_create_multi_surface(const char* name, int* frames, gr_surface** pSurfac
png_structp png_ptr = NULL; png_structp png_ptr = NULL;
png_infop info_ptr = NULL; png_infop info_ptr = NULL;
int i; int i;
GGLSurface** surface = NULL; gr_surface* surface = NULL;
*pSurface = NULL; *pSurface = NULL;
*frames = -1; *frames = -1;
@ -248,9 +230,8 @@ int res_create_multi_surface(const char* name, int* frames, gr_surface** pSurfac
int channels = png_get_channels(png_ptr, info_ptr); int channels = png_get_channels(png_ptr, info_ptr);
if (!(bit_depth == 8 && if (!(bit_depth <= 8 &&
((channels == 3 && color_type == PNG_COLOR_TYPE_RGB) || ((channels == 3 && color_type == PNG_COLOR_TYPE_RGB) ||
(channels == 4 && color_type == PNG_COLOR_TYPE_RGBA) ||
(channels == 1 && (color_type == PNG_COLOR_TYPE_PALETTE || (channels == 1 && (color_type == PNG_COLOR_TYPE_PALETTE ||
color_type == PNG_COLOR_TYPE_GRAY))))) { color_type == PNG_COLOR_TYPE_GRAY))))) {
return -7; return -7;
@ -279,38 +260,21 @@ int res_create_multi_surface(const char* name, int* frames, gr_surface** pSurfac
size_t stride = (color_type == PNG_COLOR_TYPE_GRAY ? 1 : 4) * width; size_t stride = (color_type == PNG_COLOR_TYPE_GRAY ? 1 : 4) * width;
size_t pixelSize = stride * height / *frames; size_t pixelSize = stride * height / *frames;
surface = malloc(*frames * sizeof(GGLSurface*)); surface = malloc(*frames * sizeof(gr_surface));
if (surface == NULL) { if (surface == NULL) {
result = -8; result = -8;
goto exit; goto exit;
} }
for (i = 0; i < *frames; ++i) { for (i = 0; i < *frames; ++i) {
surface[i] = malloc(sizeof(GGLSurface) + pixelSize); surface[i] = malloc_surface(pixelSize);
surface[i]->version = sizeof(GGLSurface);
surface[i]->width = width; surface[i]->width = width;
surface[i]->height = height / *frames; surface[i]->height = height / *frames;
surface[i]->stride = width; /* Yes, pixels, not bytes */ surface[i]->row_bytes = stride;
surface[i]->data = (unsigned char*) (surface[i] + 1); surface[i]->pixel_bytes = (color_type == PNG_COLOR_TYPE_GRAY ? 1 : 4);
if (channels == 3) {
surface[i]->format = GGL_PIXEL_FORMAT_RGBX_8888;
} else if (color_type == PNG_COLOR_TYPE_PALETTE) {
surface[i]->format = GGL_PIXEL_FORMAT_RGBA_8888;
} else if (channels == 1) {
surface[i]->format = GGL_PIXEL_FORMAT_L_8;
} else {
surface[i]->format = GGL_PIXEL_FORMAT_RGBA_8888;
}
} }
int alpha = (channels == 4); int alpha = (channels == 4);
if (color_type == PNG_COLOR_TYPE_PALETTE) { png_set_expand(png_ptr);
png_set_palette_to_rgb(png_ptr);
}
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
png_set_tRNS_to_alpha(png_ptr);
alpha = 1;
}
if (color_type == PNG_COLOR_TYPE_GRAY) { if (color_type == PNG_COLOR_TYPE_GRAY) {
alpha = 1; alpha = 1;
} }
@ -384,7 +348,7 @@ static int matches_locale(const char* loc) {
int res_create_localized_surface(const char* name, gr_surface* pSurface) { int res_create_localized_surface(const char* name, gr_surface* pSurface) {
char resPath[256]; char resPath[256];
GGLSurface* surface = NULL; gr_surface surface = NULL;
int result = 0; int result = 0;
unsigned char header[8]; unsigned char header[8];
png_structp png_ptr = NULL; png_structp png_ptr = NULL;
@ -438,12 +402,14 @@ int res_create_localized_surface(const char* name, gr_surface* pSurface) {
&color_type, NULL, NULL, NULL); &color_type, NULL, NULL, NULL);
int channels = png_get_channels(png_ptr, info_ptr); int channels = png_get_channels(png_ptr, info_ptr);
if (!(bit_depth == 8 && if (!(bit_depth <= 8 &&
(channels == 1 && color_type == PNG_COLOR_TYPE_GRAY))) { (channels == 1 && color_type == PNG_COLOR_TYPE_GRAY))) {
return -7; return -7;
goto exit; goto exit;
} }
png_set_expand(png_ptr);
unsigned char* row = malloc(width); unsigned char* row = malloc(width);
png_uint_32 y; png_uint_32 y;
for (y = 0; y < height; ++y) { for (y = 0; y < height; ++y) {
@ -456,19 +422,17 @@ int res_create_localized_surface(const char* name, gr_surface* pSurface) {
if (y+1+h >= height || matches_locale(loc)) { if (y+1+h >= height || matches_locale(loc)) {
printf(" %20s: %s (%d x %d @ %d)\n", name, loc, w, h, y); printf(" %20s: %s (%d x %d @ %d)\n", name, loc, w, h, y);
surface = malloc(sizeof(GGLSurface)); surface = malloc_surface(w*h);
if (surface == NULL) { if (surface == NULL) {
result = -8; result = -8;
goto exit; goto exit;
} }
unsigned char* pData = malloc(w*h); unsigned char* pData = surface->data;
surface->version = sizeof(GGLSurface);
surface->width = w; surface->width = w;
surface->height = h; surface->height = h;
surface->stride = w; /* Yes, pixels, not bytes */ surface->row_bytes = w;
surface->data = pData; surface->pixel_bytes = 1;
surface->format = GGL_PIXEL_FORMAT_A_8;
int i; int i;
for (i = 0; i < h; ++i, ++y) { for (i = 0; i < h; ++i, ++y) {
@ -501,8 +465,5 @@ exit:
} }
void res_free_surface(gr_surface surface) { void res_free_surface(gr_surface surface) {
GGLSurface* pSurface = (GGLSurface*) surface; free(surface);
if (pSurface) {
free(pSurface);
}
} }

3
mtdutils/flash_image.c
View file

@ -24,6 +24,9 @@
#include "cutils/log.h" #include "cutils/log.h"
#include "mtdutils.h" #include "mtdutils.h"
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "flash_image" #define LOG_TAG "flash_image"
#define HEADER_SIZE 2048 // size of header to compare for equality #define HEADER_SIZE 2048 // size of header to compare for equality

14
screen_ui.cpp
View file

@ -87,7 +87,7 @@ void ScreenRecoveryUI::draw_background_locked(Icon icon)
{ {
pagesIdentical = false; pagesIdentical = false;
gr_color(0, 0, 0, 255); gr_color(0, 0, 0, 255);
gr_fill(0, 0, gr_fb_width(), gr_fb_height()); gr_clear();
if (icon) { if (icon) {
gr_surface surface = backgroundIcon[icon]; gr_surface surface = backgroundIcon[icon];
@ -203,12 +203,12 @@ void ScreenRecoveryUI::SetColor(UIElement e) {
// Should only be called with updateMutex locked. // Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_screen_locked() void ScreenRecoveryUI::draw_screen_locked()
{ {
draw_background_locked(currentIcon); if (!show_text) {
draw_progress_locked(); draw_background_locked(currentIcon);
draw_progress_locked();
if (show_text) { } else {
SetColor(TEXT_FILL); gr_color(0, 0, 0, 255);
gr_fill(0, 0, gr_fb_width(), gr_fb_height()); gr_clear();
int y = 0; int y = 0;
int i = 0; int i = 0;