/* vi: set sw=4 ts=4: */ /* * Copyright (C) 2008 Michele Sanges <michele.sanges@gmail.com> * * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. * * Usage: * - use kernel option 'vga=xxx' or otherwise enable framebuffer device. * - put somewhere fbsplash.cfg file and an image in .ppm format. * - run applet: $ setsid fbsplash [params] & * -c: hide cursor * -d /dev/fbN: framebuffer device (if not /dev/fb0) * -s path_to_image_file (can be "-" for stdin) * -i path_to_cfg_file * -f path_to_fifo (can be "-" for stdin) * - if you want to run it only in presence of a kernel parameter * (for example fbsplash=on), use: * grep -q "fbsplash=on" </proc/cmdline && setsid fbsplash [params] * - commands for fifo: * "NN" (ASCII decimal number) - percentage to show on progress bar. * "exit" (or just close fifo) - well you guessed it. */ #include "libbb.h" #include <linux/fb.h> /* If you want logging messages on /tmp/fbsplash.log... */ #define DEBUG 0 #define BYTES_PER_PIXEL 2 typedef unsigned short DATA; struct globals { #if DEBUG bool bdebug_messages; // enable/disable logging FILE *logfile_fd; // log file #endif unsigned char *addr; // pointer to framebuffer memory unsigned ns[7]; // n-parameters const char *image_filename; struct fb_var_screeninfo scr_var; struct fb_fix_screeninfo scr_fix; }; #define G (*ptr_to_globals) #define INIT_G() do { \ SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \ } while (0) #define nbar_width ns[0] // progress bar width #define nbar_height ns[1] // progress bar height #define nbar_posx ns[2] // progress bar horizontal position #define nbar_posy ns[3] // progress bar vertical position #define nbar_colr ns[4] // progress bar color red component #define nbar_colg ns[5] // progress bar color green component #define nbar_colb ns[6] // progress bar color blue component #if DEBUG #define DEBUG_MESSAGE(strMessage, args...) \ if (G.bdebug_messages) { \ fprintf(G.logfile_fd, "[%s][%s] - %s\n", \ __FILE__, __FUNCTION__, strMessage); \ } #else #define DEBUG_MESSAGE(...) ((void)0) #endif /** * Open and initialize the framebuffer device * \param *strfb_device pointer to framebuffer device */ static void fb_open(const char *strfb_device) { int fbfd = xopen(strfb_device, O_RDWR); // framebuffer properties xioctl(fbfd, FBIOGET_VSCREENINFO, &G.scr_var); xioctl(fbfd, FBIOGET_FSCREENINFO, &G.scr_fix); if (G.scr_var.bits_per_pixel != 16) bb_error_msg_and_die("only 16 bpp is supported"); // map the device in memory G.addr = mmap(NULL, G.scr_var.xres * G.scr_var.yres * BYTES_PER_PIXEL /*(G.scr_var.bits_per_pixel / 8)*/, PROT_WRITE, MAP_SHARED, fbfd, 0); if (G.addr == MAP_FAILED) bb_perror_msg_and_die("mmap"); close(fbfd); } /** * Draw hollow rectangle on framebuffer */ static void fb_drawrectangle(void) { int cnt; DATA thispix; DATA *ptr1, *ptr2; unsigned char nred = G.nbar_colr/2; unsigned char ngreen = G.nbar_colg/2; unsigned char nblue = G.nbar_colb/2; nred >>= 3; // 5-bit red ngreen >>= 2; // 6-bit green nblue >>= 3; // 5-bit blue thispix = nblue + (ngreen << 5) + (nred << (5+6)); // horizontal lines ptr1 = (DATA*)(G.addr + (G.nbar_posy * G.scr_var.xres + G.nbar_posx) * BYTES_PER_PIXEL); ptr2 = (DATA*)(G.addr + ((G.nbar_posy + G.nbar_height - 1) * G.scr_var.xres + G.nbar_posx) * BYTES_PER_PIXEL); cnt = G.nbar_width - 1; do { *ptr1++ = thispix; *ptr2++ = thispix; } while (--cnt >= 0); // vertical lines ptr1 = (DATA*)(G.addr + (G.nbar_posy * G.scr_var.xres + G.nbar_posx) * BYTES_PER_PIXEL); ptr2 = (DATA*)(G.addr + (G.nbar_posy * G.scr_var.xres + G.nbar_posx + G.nbar_width - 1) * BYTES_PER_PIXEL); cnt = G.nbar_height - 1; do { *ptr1 = thispix; ptr1 += G.scr_var.xres; *ptr2 = thispix; ptr2 += G.scr_var.xres; } while (--cnt >= 0); } /** * Draw filled rectangle on framebuffer * \param nx1pos,ny1pos upper left position * \param nx2pos,ny2pos down right position * \param nred,ngreen,nblue rgb color */ static void fb_drawfullrectangle(int nx1pos, int ny1pos, int nx2pos, int ny2pos, unsigned char nred, unsigned char ngreen, unsigned char nblue) { int cnt1, cnt2, nypos; DATA thispix; DATA *ptr; nred >>= 3; // 5-bit red ngreen >>= 2; // 6-bit green nblue >>= 3; // 5-bit blue thispix = nblue + (ngreen << 5) + (nred << (5+6)); cnt1 = ny2pos - ny1pos; nypos = ny1pos; do { ptr = (DATA*)(G.addr + (nypos * G.scr_var.xres + nx1pos) * BYTES_PER_PIXEL); cnt2 = nx2pos - nx1pos; do { *ptr++ = thispix; } while (--cnt2 >= 0); nypos++; } while (--cnt1 >= 0); } /** * Draw a progress bar on framebuffer * \param percent percentage of loading */ static void fb_drawprogressbar(unsigned percent) { int i, left_x, top_y, width, height; // outer box left_x = G.nbar_posx; top_y = G.nbar_posy; width = G.nbar_width - 1; height = G.nbar_height - 1; if ((height | width) < 0) return; // NB: "width" of 1 actually makes rect with width of 2! fb_drawrectangle(); // inner "empty" rectangle left_x++; top_y++; width -= 2; height -= 2; if ((height | width) < 0) return; fb_drawfullrectangle( left_x, top_y, left_x + width, top_y + height, G.nbar_colr, G.nbar_colg, G.nbar_colb); if (percent > 0) { // actual progress bar width = width * percent / 100; i = height; if (height == 0) height++; // divide by 0 is bad while (i >= 0) { // draw one-line thick "rectangle" // top line will have gray lvl 200, bottom one 100 unsigned gray_level = 100 + i*100/height; fb_drawfullrectangle( left_x, top_y, left_x + width, top_y, gray_level, gray_level, gray_level); top_y++; i--; } } } /** * Draw image from PPM file */ static void fb_drawimage(void) { FILE *theme_file; char *read_ptr; unsigned char *pixline; unsigned i, j, width, height, line_size; if (LONE_DASH(G.image_filename)) { theme_file = stdin; } else { int fd = open_zipped(G.image_filename); if (fd < 0) bb_simple_perror_msg_and_die(G.image_filename); theme_file = xfdopen_for_read(fd); } /* Parse ppm header: * - Magic: two characters "P6". * - Whitespace (blanks, TABs, CRs, LFs). * - A width, formatted as ASCII characters in decimal. * - Whitespace. * - A height, ASCII decimal. * - Whitespace. * - The maximum color value, ASCII decimal, in 0..65535 * - Newline or other single whitespace character. * (we support newline only) * - A raster of Width * Height pixels in triplets of rgb * in pure binary by 1 or 2 bytes. (we support only 1 byte) */ #define concat_buf bb_common_bufsiz1 read_ptr = concat_buf; while (1) { int w, h, max_color_val; int rem = concat_buf + sizeof(concat_buf) - read_ptr; if (rem < 2 || fgets(read_ptr, rem, theme_file) == NULL ) { bb_error_msg_and_die("bad PPM file '%s'", G.image_filename); } read_ptr = strchrnul(read_ptr, '#'); *read_ptr = '\0'; /* ignore #comments */ if (sscanf(concat_buf, "P6 %u %u %u", &w, &h, &max_color_val) == 3 && max_color_val <= 255 ) { width = w; /* w is on stack, width may be in register */ height = h; break; } } line_size = width*3; pixline = xmalloc(line_size); if (width > G.scr_var.xres) width = G.scr_var.xres; if (height > G.scr_var.yres) height = G.scr_var.yres; for (j = 0; j < height; j++) { unsigned char *pixel; DATA *src; if (fread(pixline, 1, line_size, theme_file) != line_size) bb_error_msg_and_die("bad PPM file '%s'", G.image_filename); pixel = pixline; src = (DATA *)(G.addr + j * G.scr_fix.line_length); for (i = 0; i < width; i++) { unsigned thispix; thispix = (((unsigned)pixel[0] << 8) & 0xf800) | (((unsigned)pixel[1] << 3) & 0x07e0) | (((unsigned)pixel[2] >> 3)); *src++ = thispix; pixel += 3; } } free(pixline); fclose(theme_file); } /** * Parse configuration file * \param *cfg_filename name of the configuration file */ static void init(const char *cfg_filename) { static const char param_names[] ALIGN1 = "BAR_WIDTH\0" "BAR_HEIGHT\0" "BAR_LEFT\0" "BAR_TOP\0" "BAR_R\0" "BAR_G\0" "BAR_B\0" #if DEBUG "DEBUG\0" #endif ; char *token[2]; parser_t *parser = config_open2(cfg_filename, xfopen_stdin); while (config_read(parser, token, 2, 2, "#=", (PARSE_NORMAL | PARSE_MIN_DIE) & ~(PARSE_TRIM | PARSE_COLLAPSE))) { unsigned val = xatoi_u(token[1]); int i = index_in_strings(param_names, token[0]); if (i < 0) bb_error_msg_and_die("syntax error: %s", token[0]); if (i >= 0 && i < 7) G.ns[i] = val; #if DEBUG if (i == 7) { G.bdebug_messages = val; if (G.bdebug_messages) G.logfile_fd = xfopen_for_write("/tmp/fbsplash.log"); } #endif } config_close(parser); } int fbsplash_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; int fbsplash_main(int argc UNUSED_PARAM, char **argv) { const char *fb_device, *cfg_filename, *fifo_filename; FILE *fp = fp; // for compiler char *num_buf; unsigned num; bool bCursorOff; INIT_G(); // parse command line options fb_device = "/dev/fb0"; cfg_filename = NULL; fifo_filename = NULL; bCursorOff = 1 & getopt32(argv, "cs:d:i:f:", &G.image_filename, &fb_device, &cfg_filename, &fifo_filename); // parse configuration file if (cfg_filename) init(cfg_filename); // We must have -s IMG if (!G.image_filename) bb_show_usage(); fb_open(fb_device); if (fifo_filename && bCursorOff) { // hide cursor (BEFORE any fb ops) full_write(STDOUT_FILENO, "\033[?25l", 6); } fb_drawimage(); if (!fifo_filename) return EXIT_SUCCESS; fp = xfopen_stdin(fifo_filename); if (fp != stdin) { // For named pipes, we want to support this: // mkfifo cmd_pipe // fbsplash -f cmd_pipe .... & // ... // echo 33 >cmd_pipe // ... // echo 66 >cmd_pipe // This means that we don't want fbsplash to get EOF // when last writer closes input end. // The simplest way is to open fifo for writing too // and become an additional writer :) open(fifo_filename, O_WRONLY); // errors are ignored } fb_drawprogressbar(0); // Block on read, waiting for some input. // Use of <stdio.h> style I/O allows to correctly // handle a case when we have many buffered lines // already in the pipe while ((num_buf = xmalloc_fgetline(fp)) != NULL) { if (strncmp(num_buf, "exit", 4) == 0) { DEBUG_MESSAGE("exit"); break; } num = atoi(num_buf); if (isdigit(num_buf[0]) && (num <= 100)) { #if DEBUG DEBUG_MESSAGE(itoa(num)); #endif fb_drawprogressbar(num); } free(num_buf); } if (bCursorOff) // restore cursor full_write(STDOUT_FILENO, "\033[?25h", 6); return EXIT_SUCCESS; }