aboutsummaryrefslogtreecommitdiffstats
path: root/fbi.c
diff options
context:
space:
mode:
Diffstat (limited to 'fbi.c')
-rw-r--r--fbi.c1552
1 files changed, 1552 insertions, 0 deletions
diff --git a/fbi.c b/fbi.c
new file mode 100644
index 0000000..3ea278a
--- /dev/null
+++ b/fbi.c
@@ -0,0 +1,1552 @@
+/*
+ * image viewer, for framebuffer devices
+ *
+ * (c) 1998-2002 Gerd Knorr <kraxel@bytesex.org>
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <termios.h>
+#include <getopt.h>
+#include <math.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <ctype.h>
+#include <locale.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <linux/fb.h>
+
+#include <jpeglib.h>
+
+#include <libexif/exif-data.h>
+
+#ifdef HAVE_LIBLIRC
+# include "lirc/lirc_client.h"
+# include "lirc.h"
+#endif
+
+#include "readers.h"
+#include "dither.h"
+#include "fbtools.h"
+#include "fb-gui.h"
+#include "filter.h"
+#include "desktop.h"
+#include "list.h"
+
+#include "jpeg/transupp.h" /* Support routines for jpegtran */
+#include "jpegtools.h"
+
+#define TRUE 1
+#define FALSE 0
+#define MAX(x,y) ((x)>(y)?(x):(y))
+#define MIN(x,y) ((x)<(y)?(x):(y))
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
+
+#define KEY_EOF -1 /* ^D */
+#define KEY_ESC -2
+#define KEY_SPACE -3
+#define KEY_Q -4
+#define KEY_PGUP -5
+#define KEY_PGDN -6
+#define KEY_TIMEOUT -7
+#define KEY_TAGFILE -8
+#define KEY_PLUS -9
+#define KEY_MINUS -10
+#define KEY_VERBOSE -11
+#define KEY_ASCALE -12
+#define KEY_DESC -13
+
+/* with arg */
+#define KEY_GOTO -100
+#define KEY_SCALE -101
+
+/* edit */
+#define KEY_DELETE -200
+#define KEY_ROT_CW -201
+#define KEY_ROT_CCW -202
+
+#define DEFAULT_DEVICE "/dev/fb0"
+
+/* ---------------------------------------------------------------------- */
+
+/* lirc fd */
+int lirc = -1;
+
+/* variables for read_image */
+int32_t lut_red[256], lut_green[256], lut_blue[256];
+int dither = FALSE, pcd_res = 3, steps = 50;
+int textreading = 0, redraw = 0, statusline = 1;
+int new_image;
+int left, top;
+
+/* file list */
+struct flist {
+ int nr;
+ int tag;
+ char *name;
+ struct list_head list;
+};
+static LIST_HEAD(flist);
+static int fcount;
+static struct flist *fcurrent;
+
+/* framebuffer */
+char *fbdev = NULL;
+char *fbmode = NULL;
+int fd, switch_last, debug;
+
+unsigned short red[256], green[256], blue[256];
+struct fb_cmap cmap = { 0, 256, red, green, blue };
+
+static float fbgamma = 1;
+
+/* Command line options. */
+
+int autodown = 0;
+int autoup = 0;
+int comments = 0;
+
+struct option fbi_options[] = {
+ {"version", no_argument, NULL, 'V'}, /* version */
+ {"help", no_argument, NULL, 'h'}, /* help */
+ {"device", required_argument, NULL, 'd'}, /* device */
+ {"mode", required_argument, NULL, 'm'}, /* video mode */
+ {"gamma", required_argument, NULL, 'g'}, /* set gamma */
+ {"quiet", no_argument, NULL, 'q'}, /* quiet */
+ {"verbose", no_argument, NULL, 'v'}, /* verbose */
+ {"scroll", required_argument, NULL, 's'}, /* set scrool */
+ {"timeout", required_argument, NULL, 't'}, /* timeout value */
+ {"once", no_argument, NULL, '1'}, /* loop only once */
+ {"resolution", required_argument, NULL, 'r'}, /* select resolution */
+ {"random", no_argument, NULL, 'u'}, /* randomize images */
+ {"font", required_argument, NULL, 'f'}, /* font */
+ {"autozoom", no_argument, NULL, 'a'},
+ {"edit", no_argument, NULL, 'e'}, /* enable editing */
+ {"list", required_argument, NULL, 'l'},
+ {"vt", required_argument, NULL, 'T'},
+ {"backup", no_argument, NULL, 'b'},
+ {"preserve", no_argument, NULL, 'p'},
+
+ /* long-only options */
+ {"autoup", no_argument, &autoup, 1 },
+ {"autodown", no_argument, &autodown, 1 },
+ {"comments", no_argument, &comments, 1 },
+ {0,0,0,0}
+};
+
+/* font handling */
+static char *fontname = NULL;
+
+/* ---------------------------------------------------------------------- */
+
+static void
+version(void)
+{
+ fprintf(stderr, "fbi version " VERSION
+ " (c) 1999-2003 Gerd Knorr; compiled on %s.\n", __DATE__ );
+}
+
+static void
+usage(char *name)
+{
+ char *h;
+
+ if (NULL != (h = strrchr(name, '/')))
+ name = h+1;
+ fprintf(stderr,
+ "\n"
+ "This program displays images using the Linux framebuffer device.\n"
+ "Supported formats: PhotoCD, jpeg, ppm, gif, tiff, xwd, bmp, png.\n"
+ "It tries to use ImageMagick's convert for unknown file formats.\n"
+ "\n"
+ " Usage: %s [ options ] file1 file2 ... fileN\n"
+ "\n"
+ " --help [-h] Print this text\n"
+ " --version [-V] Show the fbi version number\n"
+ " --device [-d] dev Framebuffer device [%s]\n"
+ " --mode [-m] mode Video mode (must be listed in /etc/fb.modes)\n"
+ " - Default is current mode.\n"
+ " --gamma [-g] f Set gamma\n"
+ " --scroll [-s] n Set scroll steps in pixels (default: 50)\n"
+ " --quiet [-q] don't print anything at all\n"
+ " --verbose [-v] show print filenames all the time\n"
+ " --timeout [-t] n Load next image after N sec without any keypress\n"
+ " --once [-1] Don't loop (for use with -t).\n"
+ " --resolution [-r] n Select resolution [1..5] (PhotoCD)\n"
+ " --random [-u] Show file1 .. fileN in a random order\n"
+ " --font [-f] fn Use font fn (either console psf file or\n"
+ " X11 font spec if a font server is available\n"
+ " --autozoom [-a] Automagically pick useful zoom factor.\n"
+ " --autoup Like the above, but upscale only.\n"
+ " --autodown Like the above, but downscale only.\n"
+ " --edit [-e] enable editing commands (see man page).\n"
+ " --backup [-b] create backup files when editing.\n"
+ " --preserve [-p] preserve timestamps when editing.\n"
+ " --list [-l] file read list of images from file\n"
+ " --comments display image comments\n"
+ " --vt [-T] vt start on console #vt\n"
+ "\n"
+ "Large images can be scrolled using the cursor keys. Zoom in/out\n"
+ "works with '+' and '-'. Use ESC or 'q' to quit. Space and PgDn\n"
+ "show the next, PgUp shows the previous image. Jumping to a image\n"
+ "works with <number>g. Return acts like Space but additionally\n"
+ "prints the filename of the currently displayed image to stdout.\n"
+ "\n",
+ name, fbdev ? fbdev : "/dev/fb0");
+}
+
+/* ---------------------------------------------------------------------- */
+
+static int flist_add(char *filename)
+{
+ struct flist *f;
+
+ f = malloc(sizeof(*f));
+ memset(f,0,sizeof(*f));
+ f->name = strdup(filename);
+ list_add_tail(&f->list,&flist);
+ return 0;
+}
+
+static int flist_add_list(char *listfile)
+{
+ char filename[256];
+ FILE *list;
+
+ list = fopen(listfile,"r");
+ if (NULL == list) {
+ fprintf(stderr,"open %s: %s\n",listfile,strerror(errno));
+ return -1;
+ }
+ while (NULL != fgets(filename,sizeof(filename)-1,list)) {
+ size_t off = strcspn(filename,"\r\n");
+ if (off)
+ filename[off] = 0;
+ flist_add(filename);
+ }
+ fclose(list);
+ return 0;
+}
+
+static int flist_del(struct flist *f)
+{
+ list_del(&f->list);
+ free(f->name);
+ free(f);
+ return 0;
+}
+
+static void flist_renumber(void)
+{
+ struct list_head *item;
+ struct flist *f;
+ int i = 0;
+
+ list_for_each(item,&flist) {
+ f = list_entry(item, struct flist, list);
+ f->nr = ++i;
+ }
+ fcount = i;
+}
+
+static int flist_islast(struct flist *f)
+{
+ return (&flist == f->list.next) ? 1 : 0;
+}
+
+static int flist_isfirst(struct flist *f)
+{
+ return (&flist == f->list.prev) ? 1 : 0;
+}
+
+static struct flist* flist_first(void)
+{
+ return list_entry(flist.next, struct flist, list);
+}
+
+static struct flist* flist_next(struct flist *f, int eof, int loop)
+{
+ if (flist_islast(f)) {
+ if (eof)
+ return NULL;
+ if (loop)
+ return flist_first();
+ return f;
+ }
+ return list_entry(f->list.next, struct flist, list);
+}
+
+static struct flist* flist_prev(struct flist *f)
+{
+ if (flist_isfirst(f))
+ return f;
+ return list_entry(f->list.prev, struct flist, list);
+}
+
+static struct flist* flist_goto(int dest)
+{
+ struct list_head *item;
+ struct flist *f;
+
+ list_for_each(item,&flist) {
+ f = list_entry(item, struct flist, list);
+ if (f->nr == dest)
+ return f;
+ }
+ return NULL;
+}
+
+static void flist_randomize(void)
+{
+ struct flist *f;
+ int count;
+
+ srand((unsigned)time(NULL));
+ flist_renumber();
+ for (count = fcount; count > 0; count--) {
+ f = flist_goto((rand() % count)+1);
+ list_del(&f->list);
+ list_add_tail(&f->list,&flist);
+ flist_renumber();
+ }
+}
+
+static void flist_print_tagged(FILE *fp)
+{
+ struct list_head *item;
+ struct flist *f;
+
+ list_for_each(item,&flist) {
+ f = list_entry(item, struct flist, list);
+ if (f->tag)
+ fprintf(fp,"%s\n",f->name);
+ }
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void status(unsigned char *desc, char *info)
+{
+ int chars, ilen;
+ char *str;
+
+ if (!statusline)
+ return;
+ chars = fb_var.xres / fb_font_width();
+ str = malloc(chars+1);
+ if (info) {
+ ilen = strlen(info);
+ sprintf(str, "%-*.*s [ %s ] H - Help",
+ chars-14-ilen, chars-14-ilen, desc, info);
+ } else {
+ sprintf(str, "%-*.*s | H - Help", chars-11, chars-11, desc);
+ }
+ fb_status_line(str);
+ free(str);
+}
+
+static void show_error(unsigned char *msg)
+{
+ fb_status_line(msg);
+ sleep(2);
+}
+
+static void show_exif(struct flist *f)
+{
+ static unsigned int tags[] = {
+ 0x010f, // Manufacturer
+ 0x0110, // Model
+
+ 0x0112, // Orientation
+ 0x0132, // Date and Time
+
+ 0x01e3, // White Point
+ 0x829a, // Exposure Time
+ 0x829d, // FNumber
+ 0x9206, // Subject Distance
+ 0xa40c, // Subject Distance Range
+ 0xa405, // Focal Length In 35mm Film
+ 0x9209, // Flash
+ };
+ ExifData *ed;
+ ExifEntry *ee;
+ unsigned int tag,l1,l2,len,count,i;
+ const char *title[ARRAY_SIZE(tags)];
+ char *value[ARRAY_SIZE(tags)];
+ char *linebuffer[ARRAY_SIZE(tags)];
+
+ if (!visible)
+ return;
+
+ ed = exif_data_new_from_file(f->name);
+ if (NULL == ed) {
+ status("image has no EXIF data", NULL);
+ return;
+ }
+
+ /* pass one -- get data + calc size */
+ l1 = 0;
+ l2 = 0;
+ for (tag = 0; tag < ARRAY_SIZE(tags); tag++) {
+ ee = exif_content_get_entry (ed->ifd[EXIF_IFD_0], tags[tag]);
+ if (NULL == ee)
+ ee = exif_content_get_entry (ed->ifd[EXIF_IFD_EXIF], tags[tag]);
+ if (NULL == ee) {
+ title[tag] = NULL;
+ value[tag] = NULL;
+ continue;
+ }
+ title[tag] = exif_tag_get_title(tags[tag]);
+ value[tag] = strdup(exif_entry_get_value(ee));
+ len = strlen(title[tag]);
+ if (l1 < len)
+ l1 = len;
+ len = strlen(value[tag]);
+ if (l2 < len)
+ l2 = len;
+ }
+
+ /* pass two -- print stuff */
+ count = 0;
+ for (tag = 0; tag < ARRAY_SIZE(tags); tag++) {
+ if (NULL == title[tag])
+ continue;
+ linebuffer[count] = malloc(l1+l2+8);
+ sprintf(linebuffer[count],"%-*.*s : %-*.*s",
+ l1, l1, title[tag],
+ l2, l2, value[tag]);
+ count++;
+ }
+ fb_text_box(24,16,linebuffer,count);
+
+ /* pass three -- free data */
+ for (tag = 0; tag < ARRAY_SIZE(tags); tag++)
+ if (NULL != value[tag])
+ free(value[tag]);
+ exif_data_unref (ed);
+ for (i = 0; i < count; i++)
+ free(linebuffer[i]);
+}
+
+static void show_help(void)
+{
+ static char *help[] = {
+ "keyboard commands",
+ "~~~~~~~~~~~~~~~~~",
+ " ESC, Q - quit",
+ " pgdn, space - next image",
+ " pgup - previous image",
+ " +/- - zoom in/out",
+ " A - autozoom image",
+ " cursor keys - scroll image",
+ "",
+ " H - show this help text",
+ " I - show EXIF info",
+ " P - pause slideshow",
+ " V - toggle statusline",
+ "",
+ "available if started with --edit switch,",
+ "rotation works for jpeg images only:",
+ " shift+D - delete image",
+ " R - rotate clockwise",
+ " L - rotate counter-clockwise",
+ };
+
+ fb_text_box(24,16,help,ARRAY_SIZE(help));
+}
+
+/* ---------------------------------------------------------------------- */
+
+struct termios saved_attributes;
+int saved_fl;
+
+static void
+tty_raw(void)
+{
+ struct termios tattr;
+
+ fcntl(0,F_GETFL,&saved_fl);
+ tcgetattr (0, &saved_attributes);
+
+ fcntl(0,F_SETFL,O_NONBLOCK);
+ memcpy(&tattr,&saved_attributes,sizeof(struct termios));
+ tattr.c_lflag &= ~(ICANON|ECHO);
+ tattr.c_cc[VMIN] = 1;
+ tattr.c_cc[VTIME] = 0;
+ tcsetattr (0, TCSAFLUSH, &tattr);
+}
+
+static void
+tty_restore(void)
+{
+ fcntl(0,F_SETFL,saved_fl);
+ tcsetattr (0, TCSANOW, &saved_attributes);
+}
+
+/* testing: find key codes */
+static void debug_key(char *key)
+{
+ char linebuffer[128];
+ int i,len;
+
+ len = sprintf(linebuffer,"key: ");
+ for (i = 0; key[i] != '\0'; i++)
+ len += sprintf(linebuffer+len, "%s%c",
+ key[i] < 0x20 ? "^" : "",
+ key[i] < 0x20 ? key[i] + 0x40 : key[i]);
+ status(linebuffer, NULL);
+}
+
+static void
+console_switch(int is_busy)
+{
+ switch (fb_switch_state) {
+ case FB_REL_REQ:
+ fb_switch_release();
+ case FB_INACTIVE:
+ visible = 0;
+ break;
+ case FB_ACQ_REQ:
+ fb_switch_acquire();
+ case FB_ACTIVE:
+ visible = 1;
+ redraw = 1;
+ ioctl(fd,FBIOPAN_DISPLAY,&fb_var);
+ fb_clear_screen();
+ if (is_busy)
+ status("busy, please wait ...", NULL);
+ break;
+ default:
+ break;
+ }
+ switch_last = fb_switch_state;
+ return;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void free_image(struct ida_image *img)
+{
+ if (img) {
+ if (img->data)
+ free(img->data);
+ free(img);
+ }
+}
+
+static struct ida_image*
+read_image(char *filename)
+{
+ char command[1024];
+ struct ida_loader *loader = NULL;
+ struct ida_image *img;
+ struct list_head *item;
+ char blk[512];
+ FILE *fp;
+ unsigned int y;
+ void *data;
+
+ new_image = 1;
+
+ /* open file */
+ if (NULL == (fp = fopen(filename, "r"))) {
+ fprintf(stderr,"open %s: %s\n",filename,strerror(errno));
+ return NULL;
+ }
+ memset(blk,0,sizeof(blk));
+ fread(blk,1,sizeof(blk),fp);
+ rewind(fp);
+
+ /* pick loader */
+ list_for_each(item,&loaders) {
+ loader = list_entry(item, struct ida_loader, list);
+ if (NULL == loader->magic)
+ break;
+ if (0 == memcmp(blk+loader->moff,loader->magic,loader->mlen))
+ break;
+ loader = NULL;
+ }
+ if (NULL == loader) {
+ /* no loader found, try to use ImageMagick's convert */
+ sprintf(command,"convert -depth 8 \"%s\" ppm:-",filename);
+ if (NULL == (fp = popen(command,"r")))
+ return NULL;
+ loader = &ppm_loader;
+ }
+
+ /* load image */
+ img = malloc(sizeof(*img));
+ memset(img,0,sizeof(*img));
+ data = loader->init(fp,filename,0,&img->i,0);
+ if (NULL == data) {
+ fprintf(stderr,"loading %s [%s] FAILED\n",filename,loader->name);
+ free_image(img);
+ return NULL;
+ }
+ img->data = malloc(img->i.width * img->i.height * 3);
+ for (y = 0; y < img->i.height; y++) {
+ if (switch_last != fb_switch_state)
+ console_switch(1);
+ loader->read(img->data + img->i.width * 3 * y, y, data);
+ }
+ loader->done(data);
+ return img;
+}
+
+static struct ida_image*
+scale_image(struct ida_image *src, float scale)
+{
+ struct op_resize_parm p;
+ struct ida_rect rect;
+ struct ida_image *dest;
+ void *data;
+ unsigned int y;
+
+ dest = malloc(sizeof(*dest));
+ memset(dest,0,sizeof(*dest));
+ memset(&rect,0,sizeof(rect));
+ memset(&p,0,sizeof(p));
+
+ p.width = src->i.width * scale;
+ p.height = src->i.height * scale;
+ p.dpi = src->i.dpi;
+ if (0 == p.width)
+ p.width = 1;
+ if (0 == p.height)
+ p.height = 1;
+
+ data = desc_resize.init(src,&rect,&dest->i,&p);
+ dest->data = malloc(dest->i.width * dest->i.height * 3);
+ for (y = 0; y < dest->i.height; y++) {
+ if (switch_last != fb_switch_state)
+ console_switch(1);
+ desc_resize.work(src,&rect,
+ dest->data + 3 * dest->i.width * y,
+ y, data);
+ }
+ desc_resize.done(data);
+ return dest;
+}
+
+static float auto_scale(struct ida_image *img)
+{
+ float xs,ys,scale;
+
+ xs = (float)fb_var.xres / img->i.width;
+ ys = (float)fb_var.yres / img->i.height;
+ scale = (xs < ys) ? xs : ys;
+ return scale;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static unsigned char *
+convert_line(int bpp, int line, int owidth,
+ char unsigned *dest, char unsigned *buffer)
+{
+ unsigned char *ptr = (void*)dest;
+ unsigned short *ptr2 = (void*)dest;
+ unsigned long *ptr4 = (void*)dest;
+ int x;
+
+ switch (fb_var.bits_per_pixel) {
+ case 8:
+ dither_line(buffer, ptr, line, owidth);
+ ptr += owidth;
+ return ptr;
+ case 15:
+ case 16:
+ for (x = 0; x < owidth; x++) {
+ ptr2[x] = lut_red[buffer[x*3]] |
+ lut_green[buffer[x*3+1]] |
+ lut_blue[buffer[x*3+2]];
+ }
+ ptr2 += owidth;
+ return (char*)ptr2;
+ case 24:
+ for (x = 0; x < owidth; x++) {
+ ptr[3*x+2] = buffer[3*x+0];
+ ptr[3*x+1] = buffer[3*x+1];
+ ptr[3*x+0] = buffer[3*x+2];
+ }
+ ptr += owidth * 3;
+ return ptr;
+ case 32:
+ for (x = 0; x < owidth; x++) {
+ ptr4[x] = lut_red[buffer[x*3]] |
+ lut_green[buffer[x*3+1]] |
+ lut_blue[buffer[x*3+2]];
+ }
+ ptr4 += owidth;
+ return (char*)ptr4;
+ default:
+ /* keep compiler happy */
+ return NULL;
+ }
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void init_one(int32_t *lut, int bits, int shift)
+{
+ int i;
+
+ if (bits > 8)
+ for (i = 0; i < 256; i++)
+ lut[i] = (i << (bits + shift - 8));
+ else
+ for (i = 0; i < 256; i++)
+ lut[i] = (i >> (8 - bits)) << shift;
+}
+
+static void
+lut_init(int depth)
+{
+ if (fb_var.red.length &&
+ fb_var.green.length &&
+ fb_var.blue.length) {
+ /* fb_var.{red|green|blue} looks sane, use it */
+ init_one(lut_red, fb_var.red.length, fb_var.red.offset);
+ init_one(lut_green, fb_var.green.length, fb_var.green.offset);
+ init_one(lut_blue, fb_var.blue.length, fb_var.blue.offset);
+ } else {
+ /* fallback */
+ int i;
+ switch (depth) {
+ case 15:
+ for (i = 0; i < 256; i++) {
+ lut_red[i] = (i & 0xf8) << 7; /* bits -rrrrr-- -------- */
+ lut_green[i] = (i & 0xf8) << 2; /* bits ------gg ggg----- */
+ lut_blue[i] = (i & 0xf8) >> 3; /* bits -------- ---bbbbb */
+ }
+ break;
+ case 16:
+ for (i = 0; i < 256; i++) {
+ lut_red[i] = (i & 0xf8) << 8; /* bits rrrrr--- -------- */
+ lut_green[i] = (i & 0xfc) << 3; /* bits -----ggg ggg----- */
+ lut_blue[i] = (i & 0xf8) >> 3; /* bits -------- ---bbbbb */
+ }
+ break;
+ case 24:
+ for (i = 0; i < 256; i++) {
+ lut_red[i] = i << 16; /* byte -r-- */
+ lut_green[i] = i << 8; /* byte --g- */
+ lut_blue[i] = i; /* byte ---b */
+ }
+ break;
+ }
+ }
+}
+
+static unsigned short calc_gamma(int n, int max)
+{
+ int ret =65535.0 * pow((float)n/(max), 1 / fbgamma);
+ if (ret > 65535) ret = 65535;
+ if (ret < 0) ret = 0;
+ return ret;
+}
+
+static void
+linear_palette(int bit)
+{
+ int i, size = 256 >> (8 - bit);
+
+ for (i = 0; i < size; i++)
+ red[i] = green[i] = blue[i] = calc_gamma(i,size);
+}
+
+static void
+svga_dither_palette(int r, int g, int b)
+{
+ int rs, gs, bs, i;
+
+ rs = 256 / (r - 1);
+ gs = 256 / (g - 1);
+ bs = 256 / (b - 1);
+ for (i = 0; i < 256; i++) {
+ red[i] = calc_gamma(rs * ((i / (g * b)) % r), 255);
+ green[i] = calc_gamma(gs * ((i / b) % g), 255);
+ blue[i] = calc_gamma(bs * ((i) % b), 255);
+ }
+}
+
+static void
+svga_display_image(struct ida_image *img, int xoff, int yoff)
+{
+ unsigned int dwidth = MIN(img->i.width, fb_var.xres);
+ unsigned int dheight = MIN(img->i.height, fb_var.yres);
+ unsigned int data, video, bank, offset, bytes, y;
+
+ if (!visible)
+ return;
+ bytes = (fb_var.bits_per_pixel+7)/8;
+
+ /* offset for image data (image > screen, select visible area) */
+ offset = (yoff * img->i.width + xoff) * 3;
+
+ /* offset for video memory (image < screen, center image) */
+ video = 0, bank = 0;
+ if (img->i.width < fb_var.xres)
+ video += bytes * ((fb_var.xres - img->i.width) / 2);
+ if (img->i.height < fb_var.yres)
+ video += fb_fix.line_length * ((fb_var.yres - img->i.height) / 2);
+
+ /* go ! */
+ for (data = 0, y = 0;
+ data < img->i.width * img->i.height * 3
+ && data / img->i.width / 3 < dheight;
+ data += img->i.width * 3, video += fb_fix.line_length) {
+ convert_line(fb_var.bits_per_pixel, y++, dwidth,
+ fb_mem+video, img->data + data + offset);
+ }
+}
+
+static int
+svga_show(struct ida_image *img, int timeout, char *desc, char *info, int *nr)
+{
+ static int paused = 0;
+ int exif = 0, help = 0;
+ int rc;
+ char key[11];
+ fd_set set;
+ struct timeval limit;
+ char linebuffer[80];
+ int fdmax;
+
+ *nr = 0;
+ if (NULL == img)
+ return KEY_SPACE; /* skip */
+
+ if (new_image) {
+ /* start with centered image, if larger than screen */
+ if (img->i.width > fb_var.xres)
+ left = (img->i.width - fb_var.xres) / 2;
+ if (img->i.height > fb_var.yres && !textreading)
+ top = (img->i.height - fb_var.yres) / 2;
+ new_image = 0;
+ }
+
+ redraw = 1;
+ for (;;) {
+ if (redraw) {
+ redraw = 0;
+ if (img->i.height <= fb_var.yres) {
+ top = 0;
+ } else {
+ if (top < 0)
+ top = 0;
+ if (top + fb_var.yres > img->i.height)
+ top = img->i.height - fb_var.yres;
+ }
+ if (img->i.width <= fb_var.xres) {
+ left = 0;
+ } else {
+ if (left < 0)
+ left = 0;
+ if (left + fb_var.xres > img->i.width)
+ left = img->i.width - fb_var.xres;
+ }
+ svga_display_image(img, left, top);
+ status(desc, info);
+ }
+ if (switch_last != fb_switch_state) {
+ console_switch(0);
+ continue;
+ }
+ FD_SET(0, &set);
+ fdmax = 1;
+#ifdef HAVE_LIBLIRC
+ if (-1 != lirc) {
+ FD_SET(lirc,&set);
+ fdmax = lirc+1;
+ }
+#endif
+ limit.tv_sec = timeout;
+ limit.tv_usec = 0;
+ rc = select(fdmax, &set, NULL, NULL,
+ (-1 != timeout && !paused) ? &limit : NULL);
+ if (switch_last != fb_switch_state) {
+ console_switch(0);
+ continue;
+ }
+ if (0 == rc)
+ return KEY_TIMEOUT;
+
+ if (FD_ISSET(0,&set)) {
+ /* stdin, i.e. keyboard */
+ rc = read(0, key, sizeof(key)-1);
+ if (rc < 1) {
+ /* EOF */
+ return KEY_EOF;
+ }
+ key[rc] = 0;
+ }
+#ifdef HAVE_LIBLIRC
+ if (lirc != -1 && FD_ISSET(lirc,&set)) {
+ /* lirc input */
+ if (-1 == lirc_fbi_havedata(&rc,key)) {
+ fprintf(stderr,"lirc: connection lost\n");
+ close(lirc);
+ lirc = -1;
+ }
+ key[rc] = 0;
+ }
+#endif
+
+ if (rc == 1 && (*key == 'q' || *key == 'Q' ||
+ *key == 'e' || *key == 'E' ||
+ *key == '\x1b' || *key == '\n')) {
+ if (*key == '\n')
+ return KEY_TAGFILE;
+ if (*key == '\x1b')
+ return KEY_ESC;
+ return KEY_Q;
+
+ } else if (0 == strcmp(key, " ")) {
+ if (textreading && top < (int)(img->i.height - fb_var.yres)) {
+ redraw = 1;
+ top += (fb_var.yres-100);
+ } else {
+ return KEY_SPACE;
+ }
+
+ } else if (0 == strcmp(key, "\x1b[A") && img->i.height > fb_var.yres) {
+ redraw = 1;
+ top -= steps;
+ } else if (0 == strcmp(key, "\x1b[B") && img->i.height > fb_var.yres) {
+ redraw = 1;
+ top += steps;
+ } else if (0 == strcmp(key, "\x1b[1~") && img->i.height > fb_var.yres) {
+ redraw = 1;
+ top = 0;
+ } else if (0 == strcmp(key, "\x1b[4~")) {
+ redraw = 1;
+ top = img->i.height - fb_var.yres;
+ } else if (0 == strcmp(key, "\x1b[D") && img->i.width > fb_var.xres) {
+ redraw = 1;
+ left -= steps;
+ } else if (0 == strcmp(key, "\x1b[C") && img->i.width > fb_var.xres) {
+ redraw = 1;
+ left += steps;
+
+ } else if (0 == strcmp(key, "\x1b[5~")) {
+ return KEY_PGUP;
+ } else if (0 == strcmp(key, "\x1b[6~") ||
+ 0 == strcmp(key, "n") ||
+ 0 == strcmp(key, "N")) {
+ return KEY_PGDN;
+
+ } else if (0 == strcmp(key, "+")) {
+ return KEY_PLUS;
+ } else if (0 == strcmp(key, "-")) {
+ return KEY_MINUS;
+ } else if (0 == strcmp(key, "a") ||
+ 0 == strcmp(key, "A")) {
+ return KEY_ASCALE;
+
+ } else if (0 == strcmp(key, "p") ||
+ 0 == strcmp(key, "P")) {
+ if (-1 != timeout) {
+ paused = !paused;
+ status(paused ? "pause on " : "pause off", NULL);
+ }
+
+ } else if (0 == strcmp(key, "D")) {
+ return KEY_DELETE;
+ } else if (0 == strcmp(key, "r") ||
+ 0 == strcmp(key, "R")) {
+ return KEY_ROT_CW;
+ } else if (0 == strcmp(key, "l") ||
+ 0 == strcmp(key, "L")) {
+ return KEY_ROT_CCW;
+
+ } else if (0 == strcmp(key, "h") ||
+ 0 == strcmp(key, "H")) {
+ if (!help) {
+ show_help();
+ help = 1;
+ } else {
+ redraw = 1;
+ help = 0;
+ }
+ exif = 0;
+
+ } else if (0 == strcmp(key, "i") ||
+ 0 == strcmp(key, "I")) {
+ if (!exif) {
+ show_exif(fcurrent);
+ exif = 1;
+ } else {
+ redraw = 1;
+ exif = 0;
+ }
+ help = 0;
+
+ } else if (0 == strcmp(key, "v") ||
+ 0 == strcmp(key, "V")) {
+ return KEY_VERBOSE;
+
+ } else if (0 == strcmp(key, "t") ||
+ 0 == strcmp(key, "T")) {
+ return KEY_DESC;
+
+ } else if (rc == 1 && (*key == 'g' || *key == 'G')) {
+ return KEY_GOTO;
+ } else if (rc == 1 && (*key == 's' || *key == 'S')) {
+ return KEY_SCALE;
+ } else if (rc == 1 && *key >= '0' && *key <= '9') {
+ *nr = *nr * 10 + (*key - '0');
+ sprintf(linebuffer, "> %d",*nr);
+ status(linebuffer, NULL);
+ } else {
+
+ *nr = 0;
+#if 0
+ debug_key(key);
+#endif
+ }
+ }
+}
+
+static void scale_fix_top_left(float old, float new, struct ida_image *img)
+{
+ unsigned int width, height;
+ float cx,cy;
+
+ cx = (float)(left + fb_var.xres/2) / (img->i.width * old);
+ cy = (float)(top + fb_var.yres/2) / (img->i.height * old);
+
+ width = img->i.width * new;
+ height = img->i.height * new;
+ left = cx * width - fb_var.xres/2;
+ top = cy * height - fb_var.yres/2;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static char *my_basename(char *filename)
+{
+ char *h;
+
+ h = strrchr(filename,'/');
+ if (h)
+ return h+1;
+ return filename;
+}
+
+static char *file_desktop(char *filename)
+{
+ static char desc[128];
+ char *h;
+
+ strncpy(desc,filename,sizeof(desc)-1);
+ if (NULL != (h = strrchr(filename,'/'))) {
+ snprintf(desc,sizeof(desc),"%.*s/%s",
+ (int)(h - filename), filename,
+ ".directory");
+ } else {
+ strcpy(desc,".directory");
+ }
+ return desc;
+}
+
+static char *make_desc(struct ida_image_info *img, char *filename)
+{
+ static char linebuffer[128];
+ struct ida_extra *extra;
+ char *desc;
+ int len;
+
+ memset(linebuffer,0,sizeof(linebuffer));
+ strncpy(linebuffer,filename,sizeof(linebuffer)-1);
+
+ if (comments) {
+ extra = load_find_extra(img, EXTRA_COMMENT);
+ if (extra)
+ snprintf(linebuffer,sizeof(linebuffer),"%.*s",
+ extra->size,extra->data);
+ } else {
+ desc = file_desktop(filename);
+ len = desktop_read_entry(desc, "Comment=", linebuffer, sizeof(linebuffer));
+ if (0 != len)
+ snprintf(linebuffer+len,sizeof(linebuffer)-len,
+ " (%s)", my_basename(filename));
+ }
+
+ return linebuffer;
+}
+
+static char *make_info(struct ida_image *img, float scale)
+{
+ static char linebuffer[128];
+
+ snprintf(linebuffer, sizeof(linebuffer),
+ "%s%.0f%% %dx%d %d/%d",
+ fcurrent->tag ? "* " : "",
+ scale*100,
+ img->i.width, img->i.height,
+ fcurrent->nr, fcount);
+ return linebuffer;
+}
+
+static char edit_line(char *line, int max)
+{
+ int len = strlen(line);
+ int pos = len;
+ int rc;
+ char key[11];
+ fd_set set;
+
+ do {
+ fb_edit_line(line,pos);
+
+ FD_SET(0, &set);
+ rc = select(1, &set, NULL, NULL, NULL);
+ if (switch_last != fb_switch_state) {
+ console_switch(0);
+ continue;
+ }
+ rc = read(0, key, sizeof(key)-1);
+ if (rc < 1) {
+ /* EOF */
+ return KEY_EOF;
+ }
+ key[rc] = 0;
+
+ if (0 == strcmp(key,"\x0a")) {
+ /* Enter */
+ return 0;
+
+ } else if (0 == strcmp(key,"\x1b")) {
+ /* ESC */
+ return KEY_ESC;
+
+ } else if (0 == strcmp(key,"\x1b[C")) {
+ /* cursor right */
+ if (pos < len)
+ pos++;
+
+ } else if (0 == strcmp(key,"\x1b[D")) {
+ /* cursor left */
+ if (pos > 0)
+ pos--;
+
+ } else if (0 == strcmp(key,"\x1b[1~")) {
+ /* home */
+ pos = 0;
+
+ } else if (0 == strcmp(key,"\x1b[4~")) {
+ /* end */
+ pos = len;
+
+ } else if (0 == strcmp(key,"\x7f")) {
+ /* backspace */
+ if (pos > 0) {
+ memmove(line+pos-1,line+pos,len-pos+1);
+ pos--;
+ len--;
+ }
+
+ } else if (0 == strcmp(key,"\x1b[3~")) {
+ /* delete */
+ if (pos < len) {
+ memmove(line+pos,line+pos+1,len-pos);
+ len--;
+ }
+
+ } else if (1 == rc && isprint(key[0]) && len < max) {
+ /* new key */
+ if (pos < len)
+ memmove(line+pos+1,line+pos,len-pos+1);
+ line[pos] = key[0];
+ pos++;
+ len++;
+ line[len] = 0;
+
+ } else if (0 /* debug */) {
+ debug_key(key);
+ sleep(1);
+ }
+ } while (1);
+}
+
+static void edit_desc(char *filename)
+{
+ static char linebuffer[128];
+ char *desc;
+ int len, rc;
+
+ desc = file_desktop(filename);
+ len = desktop_read_entry(desc, "Comment=", linebuffer, sizeof(linebuffer));
+ if (0 == len) {
+ linebuffer[0] = 0;
+ len = 0;
+ }
+ rc = edit_line(linebuffer, sizeof(linebuffer)-1);
+ if (0 != rc)
+ return;
+ desktop_write_entry(desc, "Directory", "Comment=", linebuffer);
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void cleanup_and_exit(int code)
+{
+ fb_clear_mem();
+ tty_restore();
+ fb_cleanup();
+ flist_print_tagged(stdout);
+ exit(code);
+}
+
+int
+main(int argc, char *argv[])
+{
+ int timeout = -1;
+ int randomize = -1;
+ int opt_index = 0;
+ int vt = 0;
+ int backup = 0;
+ int preserve = 0;
+
+ struct ida_image *fimg = NULL;
+ struct ida_image *simg = NULL;
+ struct ida_image *img = NULL;
+ float scale = 1;
+ float newscale = 1;
+
+ int c, editable = 0, once = 0;
+ int need_read, need_refresh;
+ int i, arg, key;
+
+ char *line, *info, *desc;
+ char linebuffer[128];
+
+ if (NULL != (line = getenv("FRAMEBUFFER")))
+ fbdev = line;
+ if (NULL != (line = getenv("FBGAMMA")))
+ fbgamma = atof(line);
+ if (NULL != (line = getenv("FBFONT")))
+ fontname = line;
+
+#ifdef HAVE_LIBLIRC
+ lirc = lirc_fbi_init();
+#endif
+
+ setlocale(LC_ALL,"");
+ for (;;) {
+ c = getopt_long(argc, argv, "u1evahPqVbpr:t:m:d:g:s:f:l:T:",
+ fbi_options, &opt_index);
+ if (c == -1)
+ break;
+ switch (c) {
+ case 0:
+ /* long option, nothing to do */
+ break;
+ case '1':
+ once = 1;
+ break;
+ case 'a':
+ autoup = 1;
+ autodown = 1;
+ break;
+ case 'q':
+ statusline = 0;
+ break;
+ case 'v':
+ statusline = 1;
+ break;
+ case 'P':
+ textreading = 1;
+ break;
+ case 'g':
+ fbgamma = atof(optarg);
+ break;
+ case 'r':
+ pcd_res = atoi(optarg);
+ break;
+ case 's':
+ steps = atoi(optarg);
+ break;
+ case 't':
+ timeout = atoi(optarg);
+ break;
+ case 'u':
+ randomize = 1;
+ break;
+ case 'd':
+ fbdev = optarg;
+ break;
+ case 'm':
+ fbmode = optarg;
+ break;
+ case 'f':
+ fontname = optarg;
+ break;
+ case 'e':
+ editable = 1;
+ break;
+ case 'b':
+ backup = 1;
+ break;
+ case 'p':
+ preserve = 1;
+ break;
+ case 'l':
+ flist_add_list(optarg);
+ break;
+ case 'T':
+ vt = atoi(optarg);
+ break;
+ case 'V':
+ version();
+ exit(0);
+ break;
+ default:
+ case 'h':
+ usage(argv[0]);
+ exit(1);
+ }
+ }
+
+ for (i = optind; i < argc; i++) {
+ flist_add(argv[i]);
+ }
+ flist_renumber();
+
+ if (0 == fcount) {
+ usage(argv[0]);
+ exit(1);
+ }
+
+ if (randomize != -1)
+ flist_randomize();
+ fcurrent = flist_first();
+
+ need_read = 1;
+ need_refresh = 1;
+
+ fb_text_init1(fontname);
+ fd = fb_init(fbdev, fbmode, vt);
+ fb_catch_exit_signals();
+ fb_switch_init();
+ signal(SIGTSTP,SIG_IGN);
+ fb_text_init2();
+
+ switch (fb_var.bits_per_pixel) {
+ case 8:
+ svga_dither_palette(8, 8, 4);
+ dither = TRUE;
+ init_dither(8, 8, 4, 2);
+ break;
+ case 15:
+ case 16:
+ if (fb_fix.visual == FB_VISUAL_DIRECTCOLOR)
+ linear_palette(5);
+ if (fb_var.green.length == 5) {
+ lut_init(15);
+ } else {
+ lut_init(16);
+ }
+ break;
+ case 24:
+ if (fb_fix.visual == FB_VISUAL_DIRECTCOLOR)
+ linear_palette(8);
+ break;
+ case 32:
+ if (fb_fix.visual == FB_VISUAL_DIRECTCOLOR)
+ linear_palette(8);
+ lut_init(24);
+ break;
+ default:
+ fprintf(stderr, "Oops: %i bit/pixel ???\n",
+ fb_var.bits_per_pixel);
+ exit(1);
+ }
+ if (fb_fix.visual == FB_VISUAL_DIRECTCOLOR ||
+ fb_var.bits_per_pixel == 8) {
+ if (-1 == ioctl(fd,FBIOPUTCMAP,&cmap)) {
+ perror("ioctl FBIOPUTCMAP");
+ exit(1);
+ }
+ }
+
+ /* svga main loop */
+ tty_raw();
+ desc = NULL;
+ info = NULL;
+ for (;;) {
+ if (need_read) {
+ need_read = 0;
+ need_refresh = 1;
+ sprintf(linebuffer,"loading %s ...",fcurrent->name);
+ status(linebuffer, NULL);
+ free_image(fimg);
+ free_image(simg);
+ fimg = read_image(fcurrent->name);
+ simg = NULL;
+ img = NULL;
+ scale = 1;
+ if (fimg) {
+ if (autoup || autodown) {
+ scale = auto_scale(fimg);
+ if (scale < 1 && !autodown)
+ scale = 1;
+ if (scale > 1 && !autoup)
+ scale = 1;
+ }
+ if (scale != 1) {
+ sprintf(linebuffer,"scaling (%.0f%%) %s ...",
+ scale*100, fcurrent->name);
+ status(linebuffer, NULL);
+ simg = scale_image(fimg,scale);
+ img = simg;
+ } else {
+ img = fimg;
+ }
+ desc = make_desc(&fimg->i,fcurrent->name);
+ }
+ if (!img) {
+ sprintf(linebuffer,"%s: FAILED",fcurrent->name);
+ show_error(linebuffer);
+ }
+ }
+ if (img) {
+ if (need_refresh) {
+ need_refresh = 0;
+ if (img->i.width < fb_var.xres || img->i.height < fb_var.yres)
+ fb_clear_screen();
+ }
+ info = make_info(fimg,scale);
+ }
+ switch (key = svga_show(img, timeout, desc, info, &arg)) {
+ case KEY_DELETE:
+ if (editable) {
+ struct flist *fdel = fcurrent;
+ if (flist_islast(fcurrent))
+ fcurrent = flist_prev(fcurrent);
+ else
+ fcurrent = flist_next(fcurrent,0,0);
+ unlink(fdel->name);
+ flist_del(fdel);
+ flist_renumber();
+ need_read = 1;
+ if (list_empty(&flist)) {
+ /* deleted last one */
+ fb_clear_mem();
+ tty_restore();
+ fb_cleanup();
+ exit(0);
+ }
+ } else {
+ show_error("readonly mode, sorry [start with --edit?]");
+ }
+ break;
+ case KEY_ROT_CW:
+ case KEY_ROT_CCW:
+ {
+ if (editable) {
+ sprintf(linebuffer,"rotating %s ...",fcurrent->name);
+ status(linebuffer, NULL);
+ jpeg_transform_inplace
+ (fcurrent->name,
+ (key == KEY_ROT_CW) ? JXFORM_ROT_90 : JXFORM_ROT_270,
+ NULL,
+ NULL,0,
+ (backup ? JFLAG_FILE_BACKUP : 0) |
+ (preserve ? JFLAG_FILE_KEEP_TIME : 0) |
+ JFLAG_TRANSFORM_IMAGE |
+ JFLAG_TRANSFORM_THUMBNAIL |
+ JFLAG_UPDATE_ORIENTATION);
+ need_read = 1;
+ } else {
+ show_error("readonly mode, sorry [start with --edit?]");
+ }
+ break;
+ }
+ case KEY_TAGFILE:
+ fcurrent->tag = !fcurrent->tag;
+ /* fall throuth */
+ case KEY_SPACE:
+ need_read = 1;
+ fcurrent = flist_next(fcurrent,1,0);
+ if (NULL != fcurrent)
+ break;
+ /* else fall */
+ case KEY_ESC:
+ case KEY_Q:
+ case KEY_EOF:
+ cleanup_and_exit(0);
+ break;
+ case KEY_PGDN:
+ need_read = 1;
+ fcurrent = flist_next(fcurrent,0,0);
+ break;
+ case KEY_PGUP:
+ need_read = 1;
+ fcurrent = flist_prev(fcurrent);
+ break;
+ case KEY_TIMEOUT:
+ need_read = 1;
+ fcurrent = flist_next(fcurrent,once,1);
+ if (NULL == fcurrent) {
+ fb_clear_mem();
+ tty_restore();
+ fb_cleanup();
+ }
+ /* FIXME: wrap around */
+ break;
+ case KEY_PLUS:
+ case KEY_MINUS:
+ case KEY_ASCALE:
+ case KEY_SCALE:
+ if (key == KEY_PLUS) {
+ newscale = scale * 1.6;
+ } else if (key == KEY_MINUS) {
+ newscale = scale / 1.6;
+ } else if (key == KEY_ASCALE) {
+ newscale = auto_scale(fimg);
+ } else {
+ newscale = arg / 100;
+ }
+ if (newscale < 0.1)
+ newscale = 0.1;
+ if (newscale > 10)
+ newscale = 10;
+ scale_fix_top_left(scale, newscale, img);
+ scale = newscale;
+ sprintf(linebuffer,"scaling (%.0f%%) %s ...",
+ scale*100, fcurrent->name);
+ status(linebuffer, NULL);
+ free_image(simg);
+ simg = scale_image(fimg,scale);
+ img = simg;
+ need_refresh = 1;
+ break;
+ case KEY_GOTO:
+ if (arg > 0 && arg <= fcount) {
+ need_read = 1;
+ fcurrent = flist_goto(arg);
+ }
+ break;
+ case KEY_VERBOSE:
+ statusline = !statusline;
+ need_refresh = 1;
+ break;
+ case KEY_DESC:
+ if (!comments) {
+ edit_desc(fcurrent->name);
+ desc = make_desc(&fimg->i,fcurrent->name);
+ }
+ break;
+ }
+ }
+}
generated by cgit (git 2.34.1) at 2024-11-01 08:06:38 +0000