source: libcaca/trunk/examples/cacaview.c @ 337

Last change on this file since 337 was 337, checked in by Sam Hocevar, 16 years ago
  • configure.ac src/time.c: + Look for Sleep in -lkernel32.
  • examples/cacaview.c: + Use caca_wait_event() instead of usleep()/caca_get_event().
  • Property svn:keywords set to Id
File size: 18.3 KB
Line 
1/*
2 *  cacaview      image viewer for libcaca
3 *  Copyright (c) 2003 Sam Hocevar <sam@zoy.org>
4 *                All Rights Reserved
5 *
6 *  $Id: cacaview.c 337 2004-01-11 18:09:01Z sam $
7 *
8 *  This program is free software; you can redistribute it and/or
9 *  modify it under the terms of the GNU Lesser General Public
10 *  License as published by the Free Software Foundation; either
11 *  version 2 of the License, or (at your option) any later version.
12 *
13 *  This program is distributed in the hope that it will be useful,
14 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 *  Lesser General Public License for more details.
17 *
18 *  You should have received a copy of the GNU Lesser General Public
19 *  License along with this program; if not, write to the Free Software
20 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
21 *  02111-1307  USA
22 */
23
24#include "config.h"
25
26#include <stdio.h>
27#include <string.h>
28#include <stdlib.h>
29#include <unistd.h>
30
31#if defined(HAVE_IMLIB2_H)
32#   include <Imlib2.h>
33#else
34#   include <stdio.h>
35#endif
36
37#if defined(HAVE_SLEEP)
38#   include <windows.h>
39#endif
40
41#include "caca.h"
42
43/* Local macros */
44#define STATUS_DITHERING 1
45#define STATUS_ANTIALIASING 2
46#define STATUS_BACKGROUND 3
47
48/* Local functions */
49static void load_image(char const *);
50static void unload_image(void);
51static void draw_checkers(unsigned int, unsigned int,
52                          unsigned int, unsigned int);
53#if !defined(HAVE_IMLIB2_H)
54static int freadint(FILE *);
55static int freadshort(FILE *);
56static int freadchar(FILE *);
57#endif
58
59/* Local variables */
60#if defined(HAVE_IMLIB2_H)
61Imlib_Image image = NULL;
62#endif
63char *pixels = NULL;
64struct caca_bitmap *bitmap = NULL;
65int x, y;
66unsigned int w, h, depth, bpp, rmask, gmask, bmask, amask;
67#if !defined(HAVE_IMLIB2_H)
68unsigned int red[256], green[256], blue[256], alpha[256];
69#endif
70
71int main(int argc, char **argv)
72{
73    int quit = 0, update = 1, help = 0, fullscreen = 0, status = 0;
74    int reload = 0, zoom = 0;
75
76    char **list = NULL;
77    int current = 0, items = 0, opts = 1;
78    int i;
79
80    /* Initialise libcaca */
81    if(caca_init())
82    {
83        fprintf(stderr, "%s: unable to initialise libcaca\n", argv[0]);
84        return 1;
85    }
86
87    /* Load items into playlist */
88    for(i = 1; i < argc; i++)
89    {
90        /* Skip options except after `--' */
91        if(opts && argv[i][0] == '-')
92        {
93            if(argv[i][1] == '-' && argv[i][2] == '\0')
94                opts = 0;
95            continue;
96        }
97
98        /* Add argv[i] to the list */
99        if(items)
100            list = realloc(list, (items + 1) * sizeof(char *));
101        else
102            list = malloc(sizeof(char *));
103        list[items] = argv[i];
104        items++;
105
106        reload = 1;
107    }
108
109    /* Go ! */
110    while(!quit)
111    {
112        int ww = caca_get_width();
113        int wh = caca_get_height();
114
115        unsigned int event, new_status = 0, new_help = 0;
116
117        if(update)
118            event = caca_get_event(CACA_EVENT_KEY_PRESS);
119        else
120            event = caca_wait_event(CACA_EVENT_KEY_PRESS);
121
122        while(event)
123        {
124            unsigned int key = event & 0x00ffffff;
125
126            switch(key)
127            {
128            case 'n':
129            case 'N':
130                if(items) current = (current + 1) % items;
131                reload = 1;
132                break;
133            case 'p':
134            case 'P':
135                if(items) current = (items + current - 1) % items;
136                reload = 1;
137                break;
138            case 'f':
139            case 'F':
140                fullscreen = ~fullscreen;
141                update = 1;
142                break;
143            case 'b':
144                i = 1 + caca_get_feature(CACA_BACKGROUND);
145                if(i > CACA_BACKGROUND_MAX) i = CACA_BACKGROUND_MIN;
146                caca_set_feature(i);
147                new_status = STATUS_BACKGROUND;
148                update = 1;
149                break;
150            case 'B':
151                i = -1 + caca_get_feature(CACA_BACKGROUND);
152                if(i < CACA_BACKGROUND_MIN) i = CACA_BACKGROUND_MAX;
153                caca_set_feature(i);
154                new_status = STATUS_BACKGROUND;
155                update = 1;
156                break;
157            case 'a':
158                i = 1 + caca_get_feature(CACA_ANTIALIASING);
159                if(i > CACA_ANTIALIASING_MAX) i = CACA_ANTIALIASING_MIN;
160                caca_set_feature(i);
161                new_status = STATUS_ANTIALIASING;
162                update = 1;
163                break;
164            case 'A':
165                i = -1 + caca_get_feature(CACA_ANTIALIASING);
166                if(i < CACA_ANTIALIASING_MIN) i = CACA_ANTIALIASING_MAX;
167                caca_set_feature(i);
168                new_status = STATUS_ANTIALIASING;
169                update = 1;
170                break;
171            case 'd':
172                i = 1 + caca_get_feature(CACA_DITHERING);
173                if(i > CACA_DITHERING_MAX) i = CACA_DITHERING_MIN;
174                caca_set_feature(i);
175                new_status = STATUS_DITHERING;
176                update = 1;
177                break;
178            case 'D':
179                i = -1 + caca_get_feature(CACA_DITHERING);
180                if(i < CACA_DITHERING_MIN) i = CACA_DITHERING_MAX;
181                caca_set_feature(i);
182                new_status = STATUS_DITHERING;
183                update = 1;
184                break;
185            case '+':
186                zoom++;
187                if(zoom > 48) zoom = 48; else update = 1;
188                break;
189            case '-':
190                zoom--;
191                if(zoom < -48) zoom = -48; else update = 1;
192                break;
193            case 'x':
194            case 'X':
195                zoom = 0;
196                update = 1;
197                break;
198            case 'k':
199            case 'K':
200            case CACA_KEY_UP:
201                if(zoom > 0) y -= 1 + h / (2 + zoom) / 8;
202                update = 1;
203                break;
204            case 'j':
205            case 'J':
206            case CACA_KEY_DOWN:
207                if(zoom > 0) y += 1 + h / (2 + zoom) / 8;
208                update = 1;
209                break;
210            case 'h':
211            case 'H':
212            case CACA_KEY_LEFT:
213                if(zoom > 0) x -= 1 + w / (2 + zoom) / 8;
214                update = 1;
215                break;
216            case 'l':
217            case 'L':
218            case CACA_KEY_RIGHT:
219                if(zoom > 0) x += 1 + w / (2 + zoom) / 8;
220                update = 1;
221                break;
222            case '?':
223                new_help = !help;
224                update = 1;
225                break;
226            case 'q':
227            case 'Q':
228                quit = 1;
229                break;
230            }
231
232            if(status || new_status)
233                status = new_status;
234
235            if(help || new_help)
236                help = new_help;
237
238            event = caca_get_event(CACA_EVENT_KEY_PRESS);
239        }
240
241        if(items && reload)
242        {
243            char *buffer;
244            int len = strlen(" Loading `%s'... ") + strlen(list[current]);
245
246            if(len < ww + 1)
247                len = ww + 1;
248
249            buffer = malloc(len);
250
251            /* Reset image-specific runtime variables */
252            zoom = 0;
253
254            sprintf(buffer, " Loading `%s'... ", list[current]);
255            buffer[ww] = '\0';
256            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
257            caca_putstr((ww - strlen(buffer)) / 2, wh / 2, buffer);
258            caca_refresh();
259
260            unload_image();
261            load_image(list[current]);
262            reload = 0;
263            update = 1;
264
265            free(buffer);
266        }
267
268        caca_clear();
269
270        if(!items)
271        {
272            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
273            caca_printf(ww / 2 - 5, wh / 2, " No image. ");
274        }
275        else if(!pixels)
276        {
277#if defined(HAVE_IMLIB2_H)
278#   define ERROR_STRING " Error loading `%s'. "
279#else
280#   define ERROR_STRING " Error loading `%s'. Only BMP is supported. "
281#endif
282            char *buffer;
283            int len = strlen(ERROR_STRING) + strlen(list[current]);
284
285            if(len < ww + 1)
286                len = ww + 1;
287
288            buffer = malloc(len);
289
290            sprintf(buffer, ERROR_STRING, list[current]);
291            buffer[ww] = '\0';
292            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
293            caca_putstr((ww - strlen(buffer)) / 2, wh / 2, buffer);
294            free(buffer);
295        }
296        else if(zoom < 0)
297        {
298            int xo = (ww - 1) / 2;
299            int yo = (wh - 1) / 2;
300            int xn = (ww - 1) / (2 - zoom);
301            int yn = (wh - 1) / (2 - zoom);
302            draw_checkers(xo - xn, yo - yn, xo + xn, yo + yn);
303            caca_draw_bitmap(xo - xn, yo - yn, xo + xn, yo + yn,
304                             bitmap, pixels);
305        }
306        else if(zoom > 0)
307        {
308            struct caca_bitmap *newbitmap;
309            int xn = w / (2 + zoom);
310            int yn = h / (2 + zoom);
311            if(x < xn) x = xn;
312            if(y < yn) y = yn;
313            if(xn + x > (int)w) x = w - xn;
314            if(yn + y > (int)h) y = h - yn;
315            newbitmap = caca_create_bitmap(bpp, 2 * xn, 2 * yn, depth * w,
316                                           rmask, gmask, bmask, amask);
317#if !defined(HAVE_IMLIB2_H)
318            if(bpp == 8)
319                caca_set_bitmap_palette(newbitmap, red, green, blue, alpha);
320#endif
321            draw_checkers(0, fullscreen ? 0 : 1,
322                          ww - 1, fullscreen ? wh - 1 : wh - 3);
323            caca_draw_bitmap(0, fullscreen ? 0 : 1,
324                             ww - 1, fullscreen ? wh - 1 : wh - 3,
325                             newbitmap,
326                             pixels + depth * (x - xn) + depth * w * (y - yn));
327            caca_free_bitmap(newbitmap);
328        }
329        else
330        {
331            draw_checkers(0, fullscreen ? 0 : 1,
332                          ww - 1, fullscreen ? wh - 1 : wh - 3);
333            caca_draw_bitmap(0, fullscreen ? 0 : 1,
334                             ww - 1, fullscreen ? wh - 1 : wh - 3,
335                             bitmap, pixels);
336        }
337
338        if(!fullscreen)
339        {
340            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
341            caca_draw_line(0, 0, ww - 1, 0, ' ');
342            caca_draw_line(0, wh - 2, ww - 1, wh - 2, '-');
343            caca_putstr(0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  "
344                              "hjkl:Move  d:Dithering  a:Antialias");
345            caca_putstr(ww - strlen("?:Help"), 0, "?:Help");
346            caca_printf(3, wh - 2, "cacaview %s", VERSION);
347            caca_printf(ww - 14, wh - 2,
348                        "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
349
350            caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_BLACK);
351            caca_draw_line(0, wh - 1, ww - 1, wh - 1, ' ');
352            switch(status)
353            {
354                case STATUS_ANTIALIASING:
355                    caca_printf(0, wh - 1, "Antialiasing: %s",
356                  caca_get_feature_name(caca_get_feature(CACA_ANTIALIASING)));
357                    break;
358                case STATUS_DITHERING:
359                    caca_printf(0, wh - 1, "Dithering: %s",
360                  caca_get_feature_name(caca_get_feature(CACA_DITHERING)));
361                    break;
362                case STATUS_BACKGROUND:
363                    caca_printf(0, wh - 1, "Background: %s",
364                  caca_get_feature_name(caca_get_feature(CACA_BACKGROUND)));
365                    break;
366            }
367        }
368
369        if(help)
370        {
371            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
372            caca_putstr(ww - 25, 2,  " +: zoom in             ");
373            caca_putstr(ww - 25, 3,  " -: zoom out            ");
374            caca_putstr(ww - 25, 4,  " x: reset zoom          ");
375            caca_putstr(ww - 25, 5,  " ---------------------- ");
376            caca_putstr(ww - 25, 6,  " hjkl: move view        ");
377            caca_putstr(ww - 25, 7,  " arrows: move view      ");
378            caca_putstr(ww - 25, 8,  " ---------------------- ");
379            caca_putstr(ww - 25, 9,  " a: antialiasing method ");
380            caca_putstr(ww - 25, 10, " d: dithering method    ");
381            caca_putstr(ww - 25, 11, " b: background mode     ");
382            caca_putstr(ww - 25, 12, " ---------------------- ");
383            caca_putstr(ww - 25, 13, " ?: help                ");
384            caca_putstr(ww - 25, 14, " q: quit                ");
385        }
386
387        caca_refresh();
388        update = 0;
389    }
390
391    /* Clean up */
392    unload_image();
393    caca_end();
394
395    return 0;
396}
397
398static void unload_image(void)
399{
400#if defined(HAVE_IMLIB2_H)
401    if(image)
402        imlib_free_image();
403    image = NULL;
404    pixels = NULL;
405#else
406    if(pixels)
407        free(pixels);
408    pixels = NULL;
409#endif
410    if(bitmap)
411        caca_free_bitmap(bitmap);
412    bitmap = NULL;
413}
414
415static void load_image(char const *name)
416{
417#if defined(HAVE_IMLIB2_H)
418    /* Load the new image */
419    image = imlib_load_image(name);
420
421    if(!image)
422        return;
423
424    imlib_context_set_image(image);
425    pixels = (char *)imlib_image_get_data_for_reading_only();
426    w = imlib_image_get_width();
427    h = imlib_image_get_height();
428    rmask = 0x00ff0000;
429    gmask = 0x0000ff00;
430    bmask = 0x000000ff;
431    amask = 0xff000000;
432    bpp = 32;
433    depth = 4;
434
435    /* Create the libcaca bitmap */
436    bitmap = caca_create_bitmap(bpp, w, h, depth * w,
437                                rmask, gmask, bmask, amask);
438    if(!bitmap)
439    {
440        imlib_free_image();
441        image = NULL;
442    }
443
444#else
445    /* Try to load a BMP file */
446    FILE *fp;
447    unsigned int i, colors, offset, tmp, planes;
448
449    fp = fopen(name, "rb");
450    if(!fp)
451        return;
452
453    if(freadshort(fp) != 0x4d42)
454    {
455        fclose(fp);
456        return;
457    }
458
459    freadint(fp); /* size */
460    freadshort(fp); /* reserved 1 */
461    freadshort(fp); /* reserved 2 */
462
463    offset = freadint(fp);
464
465    tmp = freadint(fp); /* header size */
466    if(tmp == 40)
467    {
468        w = freadint(fp);
469        h = freadint(fp);
470        planes = freadshort(fp);
471        bpp = freadshort(fp);
472
473        tmp = freadint(fp); /* compression */
474        if(tmp != 0)
475        {
476            fclose(fp);
477            return;
478        }
479
480        freadint(fp); /* sizeimage */
481        freadint(fp); /* xpelspermeter */
482        freadint(fp); /* ypelspermeter */
483        freadint(fp); /* biclrused */
484        freadint(fp); /* biclrimportantn */
485
486        colors = (offset - 54) / 4;
487        for(i = 0; i < colors && i < 256; i++)
488        {
489            blue[i] = freadchar(fp) * 16;
490            green[i] = freadchar(fp) * 16;
491            red[i] = freadchar(fp) * 16;
492            alpha[i] = 0;
493            freadchar(fp);
494        }
495    }
496    else if(tmp == 12)
497    {
498        w = freadint(fp);
499        h = freadint(fp);
500        planes = freadshort(fp);
501        bpp = freadshort(fp);
502
503        colors = (offset - 26) / 3;
504        for(i = 0; i < colors && i < 256; i++)
505        {
506            blue[i] = freadchar(fp);
507            green[i] = freadchar(fp);
508            red[i] = freadchar(fp);
509            alpha[i] = 0;
510        }
511    }
512    else
513    {
514        fclose(fp);
515        return;
516    }
517
518    /* Fill the rest of the palette */
519    for(i = colors; i < 256; i++)
520        blue[i] = green[i] = red[i] = alpha[i] = 0;
521
522    depth = (bpp + 7) / 8;
523
524    /* Sanity check */
525    if(!w || w > 0x10000 || !h || h > 0x10000 || planes != 1 /*|| bpp != 24*/)
526    {
527        fclose(fp);
528        return;
529    }
530
531    /* Allocate the pixel buffer */
532    pixels = malloc(w * h * depth);
533    if(!pixels)
534    {
535        fclose(fp);
536        return;
537    }
538
539    memset(pixels, 0, w * h * depth);
540
541    /* Read the bitmap data */
542    for(i = h; i--; )
543    {
544        unsigned int j, k, bits = 0;
545
546        switch(bpp)
547        {
548            case 1:
549                for(j = 0; j < w; j++)
550                {
551                    k = j % 32;
552                    if(k == 0)
553                        bits = freadint(fp);
554                    pixels[w * i * depth + j] =
555                        (bits >> ((k & ~0xf) + 0xf - (k & 0xf))) & 0x1;
556                }
557                break;
558            case 4:
559                for(j = 0; j < w; j++)
560                {
561                    k = j % 8;
562                    if(k == 0)
563                        bits = freadint(fp);
564                    pixels[w * i * depth + j] =
565                        (bits >> (4 * ((k & ~0x1) + 0x1 - (k & 0x1)))) & 0xf;
566                }
567                break;
568            default:
569                /* Works for 8bpp, but also for 16, 24 etc. */
570                fread(pixels + w * i * depth, w * depth, 1, fp);
571                /* Pad reads to 4 bytes */
572                tmp = (w * depth) % 4;
573                tmp = (4 - tmp) % 4;
574                while(tmp--)
575                    freadchar(fp);
576                break;
577        }
578    }
579
580    switch(depth)
581    {
582    case 3:
583        rmask = 0xff0000;
584        gmask = 0x00ff00;
585        bmask = 0x0000ff;
586        amask = 0x000000;
587        break;
588    case 2: /* XXX: those are the 16 bits values */
589        rmask = 0x7c00;
590        gmask = 0x03e0;
591        bmask = 0x001f;
592        amask = 0x0000;
593        break;
594    case 1:
595    default:
596        bpp = 8;
597        rmask = gmask = bmask = amask = 0;
598        break;
599    }
600
601    fclose(fp);
602
603    /* Create the libcaca bitmap */
604    bitmap = caca_create_bitmap(bpp, w, h, depth * w,
605                                rmask, gmask, bmask, amask);
606    if(!bitmap)
607    {
608        free(pixels);
609        pixels = NULL;
610        return;
611    }
612
613    if(bpp == 8)
614        caca_set_bitmap_palette(bitmap, red, green, blue, alpha);
615#endif
616
617    x = w / 2;
618    y = h / 2;
619}
620
621static void draw_checkers(unsigned int x1, unsigned int y1,
622                          unsigned int x2, unsigned int y2)
623{
624    unsigned int xn, yn;
625
626    for(yn = y1; yn <= y2; yn++)
627        for(xn = x1; xn <= x2; xn++)
628    {
629        if((((xn - x1) / 5) ^ ((yn - y1) / 3)) & 1)
630            caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_DARKGRAY);
631        else
632            caca_set_color(CACA_COLOR_DARKGRAY, CACA_COLOR_LIGHTGRAY);
633        caca_putchar(xn, yn, ' ');
634    }
635}
636
637#if !defined(HAVE_IMLIB2_H)
638static int freadint(FILE *fp)
639{
640    unsigned char buffer[4];
641    fread(buffer, 4, 1, fp);
642    return ((int)buffer[3] << 24) | ((int)buffer[2] << 16)
643             | ((int)buffer[1] << 8) | ((int)buffer[0]);
644}
645
646static int freadshort(FILE *fp)
647{
648    unsigned char buffer[2];
649    fread(buffer, 2, 1, fp);
650    return ((int)buffer[1] << 8) | ((int)buffer[0]);
651}
652
653static int freadchar(FILE *fp)
654{
655    unsigned char buffer;
656    fread(&buffer, 1, 1, fp);
657    return (int)buffer;
658}
659#endif
660
Note: See TracBrowser for help on using the repository browser.