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

Last change on this file since 336 was 336, checked in by Sam Hocevar, 17 years ago
  • src/caca.c src/graphics.c src/io.c src/time.c: + Native win32 port.
  • 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 336 2004-01-11 05:09:02Z 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        while((event = caca_get_event(CACA_EVENT_KEY_PRESS)))
118        {
119            unsigned int key = event & 0x00ffffff;
120
121            switch(key)
122            {
123            case 'n':
124            case 'N':
125                if(items) current = (current + 1) % items;
126                reload = 1;
127                break;
128            case 'p':
129            case 'P':
130                if(items) current = (items + current - 1) % items;
131                reload = 1;
132                break;
133            case 'f':
134            case 'F':
135                fullscreen = ~fullscreen;
136                update = 1;
137                break;
138            case 'b':
139                i = 1 + caca_get_feature(CACA_BACKGROUND);
140                if(i > CACA_BACKGROUND_MAX) i = CACA_BACKGROUND_MIN;
141                caca_set_feature(i);
142                new_status = STATUS_BACKGROUND;
143                update = 1;
144                break;
145            case 'B':
146                i = -1 + caca_get_feature(CACA_BACKGROUND);
147                if(i < CACA_BACKGROUND_MIN) i = CACA_BACKGROUND_MAX;
148                caca_set_feature(i);
149                new_status = STATUS_BACKGROUND;
150                update = 1;
151                break;
152            case 'a':
153                i = 1 + caca_get_feature(CACA_ANTIALIASING);
154                if(i > CACA_ANTIALIASING_MAX) i = CACA_ANTIALIASING_MIN;
155                caca_set_feature(i);
156                new_status = STATUS_ANTIALIASING;
157                update = 1;
158                break;
159            case 'A':
160                i = -1 + caca_get_feature(CACA_ANTIALIASING);
161                if(i < CACA_ANTIALIASING_MIN) i = CACA_ANTIALIASING_MAX;
162                caca_set_feature(i);
163                new_status = STATUS_ANTIALIASING;
164                update = 1;
165                break;
166            case 'd':
167                i = 1 + caca_get_feature(CACA_DITHERING);
168                if(i > CACA_DITHERING_MAX) i = CACA_DITHERING_MIN;
169                caca_set_feature(i);
170                new_status = STATUS_DITHERING;
171                update = 1;
172                break;
173            case 'D':
174                i = -1 + caca_get_feature(CACA_DITHERING);
175                if(i < CACA_DITHERING_MIN) i = CACA_DITHERING_MAX;
176                caca_set_feature(i);
177                new_status = STATUS_DITHERING;
178                update = 1;
179                break;
180            case '+':
181                zoom++;
182                if(zoom > 48) zoom = 48; else update = 1;
183                break;
184            case '-':
185                zoom--;
186                if(zoom < -48) zoom = -48; else update = 1;
187                break;
188            case 'x':
189            case 'X':
190                zoom = 0;
191                update = 1;
192                break;
193            case 'k':
194            case 'K':
195            case CACA_KEY_UP:
196                if(zoom > 0) y -= 1 + h / (2 + zoom) / 8;
197                update = 1;
198                break;
199            case 'j':
200            case 'J':
201            case CACA_KEY_DOWN:
202                if(zoom > 0) y += 1 + h / (2 + zoom) / 8;
203                update = 1;
204                break;
205            case 'h':
206            case 'H':
207            case CACA_KEY_LEFT:
208                if(zoom > 0) x -= 1 + w / (2 + zoom) / 8;
209                update = 1;
210                break;
211            case 'l':
212            case 'L':
213            case CACA_KEY_RIGHT:
214                if(zoom > 0) x += 1 + w / (2 + zoom) / 8;
215                update = 1;
216                break;
217            case '?':
218                new_help = !help;
219                update = 1;
220                break;
221            case 'q':
222            case 'Q':
223                quit = 1;
224                break;
225            }
226
227            if(status || new_status)
228                status = new_status;
229
230            if(help || new_help)
231                help = new_help;
232        }
233
234        if(items && reload)
235        {
236            char *buffer;
237            int len = strlen(" Loading `%s'... ") + strlen(list[current]);
238
239            if(len < ww + 1)
240                len = ww + 1;
241
242            buffer = malloc(len);
243
244            /* Reset image-specific runtime variables */
245            zoom = 0;
246
247            sprintf(buffer, " Loading `%s'... ", list[current]);
248            buffer[ww] = '\0';
249            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
250            caca_putstr((ww - strlen(buffer)) / 2, wh / 2, buffer);
251            caca_refresh();
252
253            unload_image();
254            load_image(list[current]);
255            reload = 0;
256            update = 1;
257
258            free(buffer);
259        }
260
261        if(!update)
262        {
263#if defined(HAVE_USLEEP)
264            usleep(10000);
265#elif defined(HAVE_SLEEP)
266            Sleep(10);
267#endif
268            continue;
269        }
270
271        caca_clear();
272
273        if(!items)
274        {
275            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
276            caca_printf(ww / 2 - 5, wh / 2, " No image. ");
277        }
278        else if(!pixels)
279        {
280#if defined(HAVE_IMLIB2_H)
281#   define ERROR_STRING " Error loading `%s'. "
282#else
283#   define ERROR_STRING " Error loading `%s'. Only BMP is supported. "
284#endif
285            char *buffer;
286            int len = strlen(ERROR_STRING) + strlen(list[current]);
287
288            if(len < ww + 1)
289                len = ww + 1;
290
291            buffer = malloc(len);
292
293            sprintf(buffer, ERROR_STRING, list[current]);
294            buffer[ww] = '\0';
295            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
296            caca_putstr((ww - strlen(buffer)) / 2, wh / 2, buffer);
297            free(buffer);
298        }
299        else if(zoom < 0)
300        {
301            int xo = (ww - 1) / 2;
302            int yo = (wh - 1) / 2;
303            int xn = (ww - 1) / (2 - zoom);
304            int yn = (wh - 1) / (2 - zoom);
305            draw_checkers(xo - xn, yo - yn, xo + xn, yo + yn);
306            caca_draw_bitmap(xo - xn, yo - yn, xo + xn, yo + yn,
307                             bitmap, pixels);
308        }
309        else if(zoom > 0)
310        {
311            struct caca_bitmap *newbitmap;
312            int xn = w / (2 + zoom);
313            int yn = h / (2 + zoom);
314            if(x < xn) x = xn;
315            if(y < yn) y = yn;
316            if(xn + x > (int)w) x = w - xn;
317            if(yn + y > (int)h) y = h - yn;
318            newbitmap = caca_create_bitmap(bpp, 2 * xn, 2 * yn, depth * w,
319                                           rmask, gmask, bmask, amask);
320#if !defined(HAVE_IMLIB2_H)
321            if(bpp == 8)
322                caca_set_bitmap_palette(newbitmap, red, green, blue, alpha);
323#endif
324            draw_checkers(0, fullscreen ? 0 : 1,
325                          ww - 1, fullscreen ? wh - 1 : wh - 3);
326            caca_draw_bitmap(0, fullscreen ? 0 : 1,
327                             ww - 1, fullscreen ? wh - 1 : wh - 3,
328                             newbitmap,
329                             pixels + depth * (x - xn) + depth * w * (y - yn));
330            caca_free_bitmap(newbitmap);
331        }
332        else
333        {
334            draw_checkers(0, fullscreen ? 0 : 1,
335                          ww - 1, fullscreen ? wh - 1 : wh - 3);
336            caca_draw_bitmap(0, fullscreen ? 0 : 1,
337                             ww - 1, fullscreen ? wh - 1 : wh - 3,
338                             bitmap, pixels);
339        }
340
341        if(!fullscreen)
342        {
343            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
344            caca_draw_line(0, 0, ww - 1, 0, ' ');
345            caca_draw_line(0, wh - 2, ww - 1, wh - 2, '-');
346            caca_putstr(0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  "
347                              "hjkl:Move  d:Dithering  a:Antialias");
348            caca_putstr(ww - strlen("?:Help"), 0, "?:Help");
349            caca_printf(3, wh - 2, "cacaview %s", VERSION);
350            caca_printf(ww - 14, wh - 2,
351                        "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
352
353            caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_BLACK);
354            caca_draw_line(0, wh - 1, ww - 1, wh - 1, ' ');
355            switch(status)
356            {
357                case STATUS_ANTIALIASING:
358                    caca_printf(0, wh - 1, "Antialiasing: %s",
359                  caca_get_feature_name(caca_get_feature(CACA_ANTIALIASING)));
360                    break;
361                case STATUS_DITHERING:
362                    caca_printf(0, wh - 1, "Dithering: %s",
363                  caca_get_feature_name(caca_get_feature(CACA_DITHERING)));
364                    break;
365                case STATUS_BACKGROUND:
366                    caca_printf(0, wh - 1, "Background: %s",
367                  caca_get_feature_name(caca_get_feature(CACA_BACKGROUND)));
368                    break;
369            }
370        }
371
372        if(help)
373        {
374            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
375            caca_putstr(ww - 25, 2,  " +: zoom in             ");
376            caca_putstr(ww - 25, 3,  " -: zoom out            ");
377            caca_putstr(ww - 25, 4,  " x: reset zoom          ");
378            caca_putstr(ww - 25, 5,  " ---------------------- ");
379            caca_putstr(ww - 25, 6,  " hjkl: move view        ");
380            caca_putstr(ww - 25, 7,  " arrows: move view      ");
381            caca_putstr(ww - 25, 8,  " ---------------------- ");
382            caca_putstr(ww - 25, 9,  " a: antialiasing method ");
383            caca_putstr(ww - 25, 10, " d: dithering method    ");
384            caca_putstr(ww - 25, 11, " b: background mode     ");
385            caca_putstr(ww - 25, 12, " ---------------------- ");
386            caca_putstr(ww - 25, 13, " ?: help                ");
387            caca_putstr(ww - 25, 14, " q: quit                ");
388        }
389
390        caca_refresh();
391        update = 0;
392    }
393
394    /* Clean up */
395    unload_image();
396    caca_end();
397
398    return 0;
399}
400
401static void unload_image(void)
402{
403#if defined(HAVE_IMLIB2_H)
404    if(image)
405        imlib_free_image();
406    image = NULL;
407    pixels = NULL;
408#else
409    if(pixels)
410        free(pixels);
411    pixels = NULL;
412#endif
413    if(bitmap)
414        caca_free_bitmap(bitmap);
415    bitmap = NULL;
416}
417
418static void load_image(char const *name)
419{
420#if defined(HAVE_IMLIB2_H)
421    /* Load the new image */
422    image = imlib_load_image(name);
423
424    if(!image)
425        return;
426
427    imlib_context_set_image(image);
428    pixels = (char *)imlib_image_get_data_for_reading_only();
429    w = imlib_image_get_width();
430    h = imlib_image_get_height();
431    rmask = 0x00ff0000;
432    gmask = 0x0000ff00;
433    bmask = 0x000000ff;
434    amask = 0xff000000;
435    bpp = 32;
436    depth = 4;
437
438    /* Create the libcaca bitmap */
439    bitmap = caca_create_bitmap(bpp, w, h, depth * w,
440                                rmask, gmask, bmask, amask);
441    if(!bitmap)
442    {
443        imlib_free_image();
444        image = NULL;
445    }
446
447#else
448    /* Try to load a BMP file */
449    FILE *fp;
450    unsigned int i, colors, offset, tmp, planes;
451
452    fp = fopen(name, "rb");
453    if(!fp)
454        return;
455
456    if(freadshort(fp) != 0x4d42)
457    {
458        fclose(fp);
459        return;
460    }
461
462    freadint(fp); /* size */
463    freadshort(fp); /* reserved 1 */
464    freadshort(fp); /* reserved 2 */
465
466    offset = freadint(fp);
467
468    tmp = freadint(fp); /* header size */
469    if(tmp == 40)
470    {
471        w = freadint(fp);
472        h = freadint(fp);
473        planes = freadshort(fp);
474        bpp = freadshort(fp);
475
476        tmp = freadint(fp); /* compression */
477        if(tmp != 0)
478        {
479            fclose(fp);
480            return;
481        }
482
483        freadint(fp); /* sizeimage */
484        freadint(fp); /* xpelspermeter */
485        freadint(fp); /* ypelspermeter */
486        freadint(fp); /* biclrused */
487        freadint(fp); /* biclrimportantn */
488
489        colors = (offset - 54) / 4;
490        for(i = 0; i < colors && i < 256; i++)
491        {
492            blue[i] = freadchar(fp) * 16;
493            green[i] = freadchar(fp) * 16;
494            red[i] = freadchar(fp) * 16;
495            alpha[i] = 0;
496            freadchar(fp);
497        }
498    }
499    else if(tmp == 12)
500    {
501        w = freadint(fp);
502        h = freadint(fp);
503        planes = freadshort(fp);
504        bpp = freadshort(fp);
505
506        colors = (offset - 26) / 3;
507        for(i = 0; i < colors && i < 256; i++)
508        {
509            blue[i] = freadchar(fp);
510            green[i] = freadchar(fp);
511            red[i] = freadchar(fp);
512            alpha[i] = 0;
513        }
514    }
515    else
516    {
517        fclose(fp);
518        return;
519    }
520
521    /* Fill the rest of the palette */
522    for(i = colors; i < 256; i++)
523        blue[i] = green[i] = red[i] = alpha[i] = 0;
524
525    depth = (bpp + 7) / 8;
526
527    /* Sanity check */
528    if(!w || w > 0x10000 || !h || h > 0x10000 || planes != 1 /*|| bpp != 24*/)
529    {
530        fclose(fp);
531        return;
532    }
533
534    /* Allocate the pixel buffer */
535    pixels = malloc(w * h * depth);
536    if(!pixels)
537    {
538        fclose(fp);
539        return;
540    }
541
542    memset(pixels, 0, w * h * depth);
543
544    /* Read the bitmap data */
545    for(i = h; i--; )
546    {
547        unsigned int j, k, bits = 0;
548
549        switch(bpp)
550        {
551            case 1:
552                for(j = 0; j < w; j++)
553                {
554                    k = j % 32;
555                    if(k == 0)
556                        bits = freadint(fp);
557                    pixels[w * i * depth + j] =
558                        (bits >> ((k & ~0xf) + 0xf - (k & 0xf))) & 0x1;
559                }
560                break;
561            case 4:
562                for(j = 0; j < w; j++)
563                {
564                    k = j % 8;
565                    if(k == 0)
566                        bits = freadint(fp);
567                    pixels[w * i * depth + j] =
568                        (bits >> (4 * ((k & ~0x1) + 0x1 - (k & 0x1)))) & 0xf;
569                }
570                break;
571            default:
572                /* Works for 8bpp, but also for 16, 24 etc. */
573                fread(pixels + w * i * depth, w * depth, 1, fp);
574                /* Pad reads to 4 bytes */
575                tmp = (w * depth) % 4;
576                tmp = (4 - tmp) % 4;
577                while(tmp--)
578                    freadchar(fp);
579                break;
580        }
581    }
582
583    switch(depth)
584    {
585    case 3:
586        rmask = 0xff0000;
587        gmask = 0x00ff00;
588        bmask = 0x0000ff;
589        amask = 0x000000;
590        break;
591    case 2: /* XXX: those are the 16 bits values */
592        rmask = 0x7c00;
593        gmask = 0x03e0;
594        bmask = 0x001f;
595        amask = 0x0000;
596        break;
597    case 1:
598    default:
599        bpp = 8;
600        rmask = gmask = bmask = amask = 0;
601        break;
602    }
603
604    fclose(fp);
605
606    /* Create the libcaca bitmap */
607    bitmap = caca_create_bitmap(bpp, w, h, depth * w,
608                                rmask, gmask, bmask, amask);
609    if(!bitmap)
610    {
611        free(pixels);
612        pixels = NULL;
613        return;
614    }
615
616    if(bpp == 8)
617        caca_set_bitmap_palette(bitmap, red, green, blue, alpha);
618#endif
619
620    x = w / 2;
621    y = h / 2;
622}
623
624static void draw_checkers(unsigned int x1, unsigned int y1,
625                          unsigned int x2, unsigned int y2)
626{
627    unsigned int xn, yn;
628
629    for(yn = y1; yn <= y2; yn++)
630        for(xn = x1; xn <= x2; xn++)
631    {
632        if((((xn - x1) / 5) ^ ((yn - y1) / 3)) & 1)
633            caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_DARKGRAY);
634        else
635            caca_set_color(CACA_COLOR_DARKGRAY, CACA_COLOR_LIGHTGRAY);
636        caca_putchar(xn, yn, ' ');
637    }
638}
639
640#if !defined(HAVE_IMLIB2_H)
641static int freadint(FILE *fp)
642{
643    unsigned char buffer[4];
644    fread(buffer, 4, 1, fp);
645    return ((int)buffer[3] << 24) | ((int)buffer[2] << 16)
646             | ((int)buffer[1] << 8) | ((int)buffer[0]);
647}
648
649static int freadshort(FILE *fp)
650{
651    unsigned char buffer[2];
652    fread(buffer, 2, 1, fp);
653    return ((int)buffer[1] << 8) | ((int)buffer[0]);
654}
655
656static int freadchar(FILE *fp)
657{
658    unsigned char buffer;
659    fread(&buffer, 1, 1, fp);
660    return (int)buffer;
661}
662#endif
663
Note: See TracBrowser for help on using the repository browser.