int load_565rle_image_onfb(struct fb_info *info, char *filename, int start_x, int start_y) { int fd, err = 0; unsigned count, max; unsigned short *data, *bits, *ptr; if( info == NULL ) { info = registered_fb[0]; } if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = (unsigned)sys_lseek(fd, (off_t)0, 2); if (count == 0) { sys_close(fd); err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if ((unsigned)sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; bits = (unsigned short *)(info->screen_base+(fb_width(info)*start_y)*2); while (count > 3) { unsigned n = ptr[0]; if (n > max) break; memset16(bits, ptr[1], n << 1); bits += n; max -= n; ptr += 2; count -= 4; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
int screen_update(int percentage, int error) { fb->vi.yres_virtual = fb->vi.yres * 2; fb->vi.yoffset = fb->vi.yoffset ? 0 : fb->vi.yres; fb->vi.bits_per_pixel = 16; draw(fb_width(fb), fb_height(fb), fb->bits + fb->vi.yoffset * fb_width(fb), percentage, error); ioctl(fb->fd, FBIOPUT_VSCREENINFO, &fb->vi); return 0; }
static int show_565rle(const char *fn) { struct stat s; unsigned short *data, *bits, *ptr; unsigned count, max; int fd; fd = open(fn, O_RDONLY); if (fd < 0) { ALOGD("cannot open '%s'\n", fn); goto err1; } if (fstat(fd, &s) < 0) goto err2; data = mmap(0, s.st_size, PROT_READ, MAP_SHARED, fd, 0); if (data == MAP_FAILED) goto err2; max = fb_width(fb) * fb_height(fb); ptr = data; count = s.st_size; bits = fb->bits; while (count > 3) { unsigned n = ptr[0]; if (n > max) break; max -= n; while (n--) *(bits++) = ptr[1]; ptr += 2; count -= 4; } /* replicate on both pages */ memcpy(fb->bits + fb->vi.yres * fb_width(fb), fb->bits, fb_width(fb) * fb_height(fb) * 2); fb->vi.yres_virtual = fb->vi.yres * 2; fb->vi.yoffset = fb->vi.yoffset ? 0 : fb->vi.yres; /* force a flip */ fb->vi.bits_per_pixel = 16; ioctl(fb->fd, FBIOPUT_VSCREENINFO, &fb->vi); munmap(data, s.st_size); close(fd); return 0; err2: close(fd); err1: return -1; }
FrameBuffer* framebuffer_create(const char* file_name) { FrameBuffer* fb = (FrameBuffer*)calloc(1, sizeof(FrameBuffer)); do { if((fb->fd = open(file_name, O_RDWR)) < 0) break; if(ioctl(fb->fd, FBIOGET_FSCREENINFO, &fb->fix) < 0) break; if(ioctl(fb->fd, FBIOGET_VSCREENINFO, &fb->var) < 0) break; fb->buffer = mmap(0, fb_size(fb), PROT_READ | PROT_WRITE, MAP_SHARED, fb->fd, 0); if(fb->buffer == MAP_FAILED) break; printf("%s: width=%d height=%d\n", file_name, fb_width(fb), fb_height(fb)); return fb; }while(0); if(fb != NULL) { if(fb->fd > 0) { close(fb->fd); } free(fb); } return NULL; }
int load_image_display(void) { struct fb_info *info; unsigned max; unsigned short *bits, *ptr; printk(KERN_WARNING "%s: \n", __FUNCTION__); info = registered_fb[0]; if( !info ) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __FUNCTION__); return -ENODEV; } max = fb_width(info) * fb_height(info); ptr = data; //bits = (unsigned short *)(info->screen_base) + (info->var.xres *info->var.yoffset * (info->var.bits_per_pixel/8)); bits = (unsigned short *)(info->screen_base) ; while (count > 3) { unsigned n = ptr[0]; if (n > max) break; memset16(bits, ptr[1], n << 1); bits += n; max -= n; ptr += 2; count -= 4; } return 0; }
static sqInt display_ioShowDisplay(sqInt dispBitsIndex, sqInt width, sqInt height, sqInt depth, sqInt affectedL, sqInt affectedR, sqInt affectedT, sqInt affectedB) { if ((depth != fb_depth(fb)) || (width != fb_width(fb)) || (height != fb_height(fb)) || (affectedR < affectedL) || (affectedB < affectedT)) return 0; fb->copyBits(fb, pointerForOop(dispBitsIndex), affectedL, affectedR, affectedT, affectedB); return 1; }
static inline unsigned long fb_getPixel_8(_self, int x, int y) { return ((x >= 0) && (y >= 0) && (x < fb_width(self)) && (y < fb_height(self))) ? *((unsigned char *)(self->addr + (x + self->var.xoffset) + (y + self->var.yoffset) * (self->fix.line_length))) : 0; }
int load_565rle_image(char *fn) { struct FB fb; struct stat s; unsigned short *data, *bits, *ptr; unsigned count, max; int fd; if (vt_set_mode(1)) return -1; fd = open(fn, O_RDONLY); if (fd < 0) { ERROR("cannot open '%s'\n", fn); goto fail_restore_text; } if (fstat(fd, &s) < 0) { goto fail_close_file; } data = mmap(0, s.st_size, PROT_READ, MAP_SHARED, fd, 0); if (data == MAP_FAILED) goto fail_close_file; if (fb_open(&fb)) goto fail_unmap_data; max = fb_width(&fb) * fb_height(&fb); ptr = data; count = s.st_size; bits = fb.bits; while (count > 3) { unsigned n = ptr[0]; if (n > max) break; android_memset16(bits, ptr[1], n << 1); bits += n; max -= n; ptr += 2; count -= 4; } munmap(data, s.st_size); fb_update(&fb); fb_close(&fb); close(fd); unlink(fn); return 0; fail_unmap_data: munmap(data, s.st_size); fail_close_file: close(fd); fail_restore_text: vt_set_mode(0); return -1; }
void main_draw_shape(struct template_t *tmp_tpl) { char *sval = NULL; if(template_get_setting_string(tmp_tpl, "shape", &sval) == 0) { int filled = 0, x = 0, y = 0, width = fb_width(), height = fb_height(), border = 0, fcolor = 0; int x1 = 0, x2 = 0, y1 = 0, y2 = 0, radius = 0, thickness = 1, zindex = 0; unsigned short *color = NULL; if(strcmp(sval, "rectangle") == 0 || strcmp(sval, "circle") == 0) { template_get_setting_number(tmp_tpl, "x", &x); template_get_setting_number(tmp_tpl, "y", &y); template_get_setting_number(tmp_tpl, "border", &border); template_get_setting_number(tmp_tpl, "filled", &filled); } else if(strcmp(sval, "line") == 0) { template_get_setting_number(tmp_tpl, "x1", &x1); template_get_setting_number(tmp_tpl, "x2", &x2); template_get_setting_number(tmp_tpl, "y1", &y1); template_get_setting_number(tmp_tpl, "y2", &y2); template_get_setting_number(tmp_tpl, "thickness", &thickness); } if(strcmp(sval, "rectangle") == 0) { template_get_setting_number(tmp_tpl, "width", &width); template_get_setting_number(tmp_tpl, "height", &height); } else if(strcmp(sval, "circle") == 0) { template_get_setting_number(tmp_tpl, "radius", &radius); } if(template_get_setting_color(tmp_tpl, "color", &color) != 0) { color = malloc(sizeof(unsigned short)*3); color[0] = 0, color[1] = 0, color[2] = 0; fcolor = 1; } template_get_setting_number(tmp_tpl, "z-index", &zindex); if(nodaemon == 0) { if(strcmp(sval, "rectangle") == 0) { if(filled) { draw_rectangle_filled(x, y, zindex, width, height, draw_color(color[0], color[1], color[2])); } else { draw_rectangle(x, y, zindex, width, height, border, draw_color(color[0], color[1], color[2])); } } else if(strcmp(sval, "circle") == 0) { if(filled) { draw_circle_filled(x, y, zindex, radius, draw_color(color[0], color[1], color[2])); } else { draw_circle(x, y, zindex, radius, border, draw_color(color[0], color[1], color[2])); } } else if(strcmp(sval, "line") == 0) { draw_line(x1, y1, x2, y2, zindex, thickness, draw_color(color[0], color[1], color[2])); } } if(fcolor) { free(color); } } }
static inline void fb_putPixel_8(_self, int x, int y, unsigned long pix) { if ((x >= 0) && (y >= 0) && (x < fb_width(self)) && (y < fb_height(self))) { *((unsigned char *)(self->addr + (x + self->var.xoffset) + (y + self->var.yoffset) * (self->fix.line_length))) = pix; } }
int screen_shot(const char * path) { struct FB * fb = NULL; fb = fb_create(1); if (fb) { save_bmp(path, fb_width(fb), fb_height(fb), fb_bits(fb), fb_bpp(fb)); fb_destory(fb); } return 0; }
static int file_to_fb(const char * srcpath) { int ret = -1; BMP_READ * bmp = NULL; struct FB * fb = NULL; int sw, sh; int srcbpp, dstbpp; void * pdata = NULL, * bmpdata = NULL; RGB_CONVERT_FUN convert_func = NULL; do { bmp = bmp_open(srcpath); if (!bmp) { break; } fb = fb_create(0); if (!fb) { break; } sw = bmp_width(bmp); sh = bmp_height(bmp); bmpdata = bmp_data(bmp); srcbpp = bmp_bpp(bmp); dstbpp = fb_bpp(fb); convert_func = get_convert_func(srcbpp, dstbpp); if (convert_func) { pdata = convert_func(bmpdata, sw, sh); bmpdata = pdata; } if (!bmp_forward(bmp)) { line_reversal(bmpdata, sw, sh, dstbpp); } rgb_copy(bmpdata, fb_bits(fb), sw, sh, fb_width(fb), fb_height(fb), dstbpp); ret = 0; } while (0); fb_destory(fb); bmp_close(bmp); if (pdata) { free(pdata); } return ret; }
w3mimg_op * w3mimg_fbopen() { w3mimg_op *wop = NULL; wop = (w3mimg_op *) malloc(sizeof(w3mimg_op)); if (wop == NULL) return NULL; memset(wop, 0, sizeof(w3mimg_op)); if (!check_tty_console(getenv("W3M_TTY")) && strncmp("fbterm", getenv("TERM"), 6) != 0 && strncmp("jfbterm", getenv("TERM"), 7) != 0) { fprintf(stderr, "w3mimgdisplay/fb: tty is not console\n"); goto error; } if (fb_open()) goto error; wop->width = fb_width(); wop->height = fb_height(); wop->init = w3mfb_init; wop->finish = w3mfb_finish; wop->active = w3mfb_active; wop->set_background = w3mfb_set_background; wop->sync = w3mfb_sync; wop->close = w3mfb_close; wop->clear = w3mfb_clear; wop->load_image = w3mfb_load_image; wop->show_image = w3mfb_show_image; wop->free_image = w3mfb_free_image; wop->get_image_size = w3mfb_get_image_size; /* XXX */ fb_image_init(); return wop; error: free(wop); return NULL; }
static int fb_to_file(const char * dstpath, int output_rgb) { int ret = -1; int w, h; int srcbpp, dstbpp; void * pdata = NULL, * fbdata = NULL; RGB_CONVERT_FUN convert_func = NULL; struct FB * fb = NULL; do { fb = fb_create(1); if (!fb) { break; } w = fb_width(fb); h = fb_height(fb); fbdata = fb_bits(fb); srcbpp = fb_bpp(fb); dstbpp = g_rgbbpp[output_rgb]; convert_func = get_convert_func(srcbpp, dstbpp); if (convert_func) { pdata = convert_func(fbdata, w, h); fbdata = pdata; } ret = save_bmp(dstpath, w, h, fbdata, dstbpp); } while (0); if (pdata) { free(pdata); } fb_destory(fb); return ret; }
void fb_init_zmap(void) { size_t zindexes = ZINDEXES, width = fb_width(), height = fb_height(); int a = 0, b = 0; if(!(zmap = calloc(zindexes, sizeof(int**)))) { logprintf(LOG_ERR, "out of memory"); exit(EXIT_FAILURE); } for(a=0;a<zindexes;a++) { if(!(zmap[a] = calloc(width, sizeof(int*)))) { logprintf(LOG_ERR, "out of memory"); exit(EXIT_FAILURE); } for(b=0;b<width;b++) { if(!(zmap[a][b] = calloc(height, sizeof(int)))) { fprintf(stderr, "out of memory"); exit(EXIT_FAILURE); } } } }
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */ int load_565rle_image(char *filename) { struct fb_info *info; int fd, err = 0; unsigned count, max, width, stride, line_pos = 0; unsigned short *data, *ptr; unsigned char *bits; info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } if (!info->screen_base) { printk(KERN_WARNING "Framebuffer memory not allocated\n"); return -ENOMEM; } fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } width = fb_width(info); stride = fb_linewidth(info); max = width * fb_height(info); ptr = data; bits = (unsigned char *)(info->screen_base); while (count > 3) { int n = ptr[0]; if (n > max) break; max -= n; while (n > 0) { unsigned int j = (line_pos + n > width ? width-line_pos : n); if (fb_depth(info) == 2) memset16(bits, ptr[1], j << 1); else { unsigned int widepixel = ptr[1]; /* * Format is RGBA, but fb is big * endian so we should make widepixel * as ABGR. */ widepixel = /* red : f800 -> 000000f8 */ (widepixel & 0xf800) >> 8 | /* green : 07e0 -> 0000fc00 */ (widepixel & 0x07e0) << 5 | /* blue : 001f -> 00f80000 */ (widepixel & 0x001f) << 19; memset32(bits, widepixel, j << 2); } bits += j * fb_depth(info); line_pos += j; n -= j; if (line_pos == width) { bits += (stride-width) * fb_depth(info); line_pos = 0; } } ptr += 2; count -= 4; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
/* 888RLE image format: [count(2 bytes), rle(3 bytes)] */ int load_565rle_image(char *filename) { struct fb_info *info; int fd, count, err = 0; unsigned max; unsigned char *data, *ptr; unsigned int *bits; unsigned int pixel; info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; bits = (unsigned int *)(info->screen_base); while (count > 4) { unsigned n = ptr[0] | ptr[1] << 8; if (n > max) break; pixel = (0xff<<24)|(ptr[4]<<16)|(ptr[3]<<8)|ptr[2]; memset32(bits, pixel, n << 1); bits += n; max -= n; ptr += 5; count -= 5; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */ static int load_565rle_image(char *filename) { struct fb_info *info; int fd, err = 0; unsigned max, width, stride, line_pos = 0; unsigned short *data, *ptr; unsigned char *bits; signed count; info = registered_fb[0]; if (!info) { printk(KERN_ERR "%s: Can not access framebuffer\n", __func__); return -ENODEV; } fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_ERR "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; printk(KERN_ERR "%s: sys_lseek failed %s\n", __func__, filename); goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_ERR "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { err = -EIO; printk(KERN_ERR "%s: sys_read failed %s\n", __func__, filename); goto err_logo_free_data; } width = fb_width(info); stride = fb_linewidth(info); max = width * fb_height(info); ptr = data; bits = (unsigned char *)(info->screen_base); while (count > 3) { int n = ptr[0]; if (n > max) break; max -= n; while (n > 0) { unsigned int j = (line_pos+n > width ? width-line_pos : n); if (fb_depth(info) == 2) { memset16(bits, ptr[1], j << 1); } else { /* Should probably add check for framebuffer * format here*/ unsigned int widepixel = ptr[1]; widepixel = (widepixel & 0xf800) << (19-11) | (widepixel & 0x07e0) << (10-5) | (widepixel & 0x001f) << (3-0) | 0xff000000; /* Set alpha channel*/ memset32(bits, widepixel, j << 2); } bits += j * fb_depth(info); line_pos += j; n -= j; if (line_pos == width) { bits += (stride-width) * fb_depth(info); line_pos = 0; } } ptr += 2; count -= 4; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */ int load_565rle_image(char *filename) { struct fb_info *info; int fd, count, err = 0; unsigned max; unsigned short *data, *ptr; char *bits; pixel_set_t pixel_set; info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } switch (info->var.bits_per_pixel) { case 16: pixel_set = memset16; break; case 32: pixel_set = pixel_set_rgba; break; default: printk(KERN_WARNING "%s: Can not find pixel_set operation\n", __func__); return -EDOM; } fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; bits = info->screen_base; while (count > 3) { unsigned n = ptr[0]; if (n > max) break; bits += pixel_set(bits, ptr[1], n); max -= n; ptr += 2; count -= 4; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */ int load_565rle_image(char *filename, bool bf_supported) { struct fb_info *info; int fd, count, err = 0; unsigned max; unsigned short *data, *bits, *ptr; #ifndef CONFIG_FRAMEBUFFER_CONSOLE struct module *owner; #endif int pad; info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } #ifndef CONFIG_FRAMEBUFFER_CONSOLE owner = info->fbops->owner; if (!try_module_get(owner)) return -ENODEV; if (info->fbops->fb_open && info->fbops->fb_open(info, 0)) { module_put(owner); return -ENODEV; } #endif fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; if (bf_supported && (info->node == 1 || info->node == 2)) { err = -EPERM; pr_err("%s:%d no info->creen_base on fb%d!\n", __func__, __LINE__, info->node); goto err_logo_free_data; } if (info->screen_base) { bits = (unsigned short *)(info->screen_base); while (count > 3) { unsigned n = ptr[0]; if (n > max) break; if (info->var.bits_per_pixel >= 24) { pad = memset16_rgb8888(bits, ptr[1], n << 1, info); bits += n << 1; bits += pad; } else { memset16(bits, ptr[1], n << 1); bits += n; } max -= n; ptr += 2; count -= 4; } } err = 0; err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
int load_565rle_image(char *filename, bool bf_supported) { int fd, err = 0; unsigned count, max; unsigned short *data, *bits, *ptr; struct fb_info *info; #if 0 struct module *owner; #endif info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } #if 0 owner = info->fbops->owner; if (!try_module_get(owner)) return NULL; if (info->fbops->fb_open && info->fbops->fb_open(info, 0)) { module_put(owner); return NULL; } #endif fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } printk("%s: open OK! %s\n",__func__, filename); count = (unsigned)sys_lseek(fd, (off_t)0, 2); if (count == 0) { sys_close(fd); err = -EIO; goto err_logo_close_file; } printk("%s: count %d\n",__func__, count); sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if ((unsigned)sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; bits = (unsigned short *)(info->screen_base); printk("%s: max %d, n %d 0x%x\n",__func__, max, ptr[0], (unsigned int)bits); while (count > 3) { unsigned n = ptr[0]; if (n > max) break; memset16_rgb8888(bits, ptr[1], n << 1); bits += n*2; // for rgb8888 max -= n; ptr += 2; count -= 4; } #if !defined (CONFIG_USA_OPERATOR_ATT) && !defined (CONFIG_JPN_MODEL_SC_03D) && !defined (CONFIG_CAN_OPERATOR_RWC) if (!is_lpcharging_state() && !sec_debug_is_recovery_mode()) s3cfb_start_progress(info); #endif err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
int load_888rle_image(char *filename) { struct fb_info *info; int fd, count, err = 0; unsigned max; unsigned short *data, *ptr; char *bits; printk(KERN_INFO "%s: load_888rle_image filename: %s\n", __func__, filename); info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { printk(KERN_WARNING "%s: Can not read data\n", __func__); err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; bits = (char *)(info->screen_base); while (count > 3) { unsigned n = ptr[0]; if (n > max) break; if (info->var.bits_per_pixel/8 == 4) memset32(bits, ptr[1], n << 1); else memset16(bits, ptr[1], n << 1); bits += info->var.bits_per_pixel/8*n; max -= n; ptr += 2; count -= 4; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
/*MTD-MM-CL-DrawLogo-00+[*/ int fih_load_565rle_image(char *filename) { struct fb_info *info = NULL; struct file *filp = NULL; unsigned short *ptr = NULL; unsigned char *bits = NULL; unsigned char *data = NULL; unsigned max = 0; int bits_count = 0, count = 0, err = 0; mm_segment_t old_fs = get_fs(); set_fs (get_ds()); printk(KERN_INFO "[DISPLAY] %s\n", __func__); info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } filp = filp_open(filename, O_RDONLY, 0); if (IS_ERR(filp)) { printk(KERN_ERR "%s: Can not open %s\n", __func__, filename); err = -ENOENT; goto error2; } count = filp->f_dentry->d_inode->i_size; data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_ERR "%s: Can not alloc data\n", __func__); err = -ENOMEM;; goto error1; } if (filp->f_op->read(filp, data, count, &filp->f_pos) < 0) { printk(KERN_ERR "%s: read file error?\n", __func__); err = -EIO; goto error1; } max = fb_width(info) * fb_height(info); ptr = (unsigned short *)data; bits = (unsigned char *)(info->screen_base); while (count > 3) { unsigned n = ptr[0]; if (n > max) break; bits_count = n; #if defined(CONFIG_FB_MSM_DEFAULT_DEPTH_RGBA8888) while (bits_count--) { *bits++ = (ptr[1] & 0xF800) >> 8; *bits++ = (ptr[1] & 0x7E0) >> 3; *bits++ = (ptr[1] & 0x1F) << 3; *bits++ = 0xFF; } #else memset16(bits, ptr[1], n << 1); bits += n; #endif max -= n; ptr += 2; count -= 4; } error1: filp_close(filp, NULL); kfree(data); error2: set_fs(old_fs); return err; }
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */ int load_565rle_image(char *filename) { struct fb_info *info; int fd, count, err = 0; unsigned max; #ifdef CONFIG_PANTECH_FB_24BPP_RGB888 IBUF_TYPE *data, *bits, *ptr; #else unsigned short *data, *bits, *ptr; #endif info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; #ifdef CONFIG_PANTECH_FB_24BPP_RGB888 bits = (IBUF_TYPE *)(info->screen_base); #else bits = (unsigned short *)(info->screen_base); #endif while (count > 3) { unsigned n = ptr[0]; if (n > max) break; #ifdef CONFIG_PANTECH_FB_24BPP_RGB888 memset32((unsigned int *)bits, ptr[1], n << 2); #else memset16(bits, ptr[1], n << 1); #endif bits += n; max -= n; ptr += 2; count -= 4; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
static sqInt display_ioScreenSize(void) { return ((fb_width(fb) << 16) | fb_height(fb)); }
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */ int load_565rle_image(char *filename) { struct fb_info *info; int fd, count, err = 0; unsigned max; unsigned short *data, *bits, *ptr; info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; if (info->node == 1 || info->node == 2) { err = -EPERM; pr_err("%s:%d no info->creen_base on fb%d!\n", __func__, __LINE__, info->node); goto err_logo_free_data; } bits = (unsigned short *)(info->screen_base); while (count > 3) { unsigned n = ptr[0]; if (n > max) break; memset16(bits, ptr[1], n << 1); bits += n; max -= n; ptr += 2; count -= 4; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
void main_draw_black(void) { if(nodaemon == 0) { draw_rectangle_filled(0, 0, -1, fb_width(), fb_height(), draw_color(0, 0, 0)); } }
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */ int load_565rle_image(char *filename) { struct fb_info *info; int fd, err = 0; unsigned count, max; unsigned short *data, *bits, *ptr; printk("LUYA!!!!1 load_565rle_image\n"); info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } printk("LUYA!!!!2 load_565rle_image\n"); fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } max = fb_width(info) * fb_height(info)*2; printk("LUYA!!!!max=%d\n",max); count = (unsigned)sys_lseek(fd, (off_t)0, 2); printk("LUYA!!!!count=%d\n",count); if (count == 0) { sys_close(fd); err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if ((unsigned)sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } ptr = data+27; bits = (unsigned short *)(info->screen_base); while (max > 0) { // unsigned n = ptr[0]; // if (n > max) // break; memset16(bits, ptr[0], 1 << 1); bits += 1; max -= 1; ptr += 1; // count -= 1; } err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); return err; }
/*MTD-MM-CL-DrawLogo-00+[*/ int fih_load_565rle_image(char *filename) { struct fb_info *info; int count, err = 0; unsigned max; unsigned short *bits, *ptr; unsigned char *data; struct file *filp=NULL; struct inode *inode = NULL; mm_segment_t old_fs = get_fs(); set_fs (KERNEL_DS); info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } filp = filp_open(filename, O_RDONLY, 0); if (IS_ERR(filp)) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); err=-ENOENT; goto error2; } inode = filp->f_dentry->d_inode; count = inode->i_size; data = kmalloc(count, GFP_KERNEL); if(data==NULL) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM;; goto error1; } if(filp->f_op->read(filp, data, count, &filp->f_pos)<0) { printk(KERN_WARNING"%s:read file error?\n", __func__); err = -EIO; } max = fb_width(info) * fb_height(info); ptr = (unsigned short *)data; bits = (unsigned short *)(info->screen_base); while (count > 3) { unsigned n = ptr[0]; if (n > max) break; memset16(bits, ptr[1], n << 1); bits += n; max -= n; ptr += 2; count -= 4; } error1: filp_close(filp,NULL); kfree(data); error2: set_fs (old_fs); return err; }
/* 565RLE image format: [count(2 bytes), rle(2 bytes)] */ int load_565rle_image(char *filename) { struct fb_info *info; int fd, count, err = 0; unsigned max; unsigned short *data, *bits, *ptr; #ifndef CONFIG_FRAMEBUFFER_CONSOLE struct module *owner; #endif int pad; info = registered_fb[0]; if (!info) { printk(KERN_WARNING "%s: Can not access framebuffer\n", __func__); return -ENODEV; } #ifndef CONFIG_FRAMEBUFFER_CONSOLE owner = info->fbops->owner; if (!try_module_get(owner)) return -ENODEV; if (info->fbops->fb_open && info->fbops->fb_open(info, 0)) { module_put(owner); return -ENODEV; } #endif fd = sys_open(filename, O_RDONLY, 0); if (fd < 0) { printk(KERN_WARNING "%s: Can not open %s\n", __func__, filename); return -ENOENT; } count = sys_lseek(fd, (off_t)0, 2); if (count <= 0) { err = -EIO; goto err_logo_close_file; } sys_lseek(fd, (off_t)0, 0); data = kmalloc(count, GFP_KERNEL); if (!data) { printk(KERN_WARNING "%s: Can not alloc data\n", __func__); err = -ENOMEM; goto err_logo_close_file; } if (sys_read(fd, (char *)data, count) != count) { err = -EIO; goto err_logo_free_data; } max = fb_width(info) * fb_height(info); ptr = data; bits = (unsigned short *)(info->screen_base); while (count > 3) { unsigned n = ptr[0]; if (n > max) break; if (info->var.bits_per_pixel >= 24) { pad = memset16_rgb8888(bits, ptr[1], n << 1, info); bits += n << 1; bits += pad; } else { memset16(bits, ptr[1], n << 1); bits += n; } max -= n; ptr += 2; count -= 4; } #if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT) \ || defined(CONFIG_FB_MSM_MIPI_NOVATEK_BOE_CMD_WVGA_PT) flush_cache_all(); outer_flush_all(); #endif err_logo_free_data: kfree(data); err_logo_close_file: sys_close(fd); #ifndef CONFIG_FRAMEBUFFER_CONSOLE err = fb_pan_display(info, &info->var); if (err < 0) { printk(KERN_WARNING "%s: Can not update framebuffer\n", __func__); return -ENODEV; } #endif return err; }