Ignore:
Timestamp:
Apr 11, 2006, 12:05:48 PM (15 years ago)
Author:
Sam Hocevar
Message:
Location:
libcaca/trunk/src
Files:
1 edited
1 copied

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/src

    • Property svn:ignore
      •  

        old new  
        1010cacaplay
        1111cacaserver
         12img2irc
        1213*.exe
  • libcaca/trunk/src/common-image.c

    r734 r739  
    11/*
    2  *  cacaview      image viewer for libcaca
    3  *  Copyright (c) 2003 Sam Hocevar <sam@zoy.org>
     2 *  Imaging tools for cacaview and img2irc
     3 *  Copyright (c) 2003, 2004, 2005, 2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    2424#endif
    2525
    26 #if defined(HAVE_SLEEP)
    27 #   include <windows.h>
    28 #endif
    29 
    3026#include "cucul.h"
    31 #include "caca.h"
    32 
    33 /* Local macros */
    34 #define MODE_IMAGE 1
    35 #define MODE_FILES 2
    36 
    37 #define STATUS_DITHERING 1
    38 #define STATUS_ANTIALIASING 2
    39 #define STATUS_BACKGROUND 3
    40 
    41 #define ZOOM_FACTOR 1.08f
    42 #define ZOOM_MAX 50
    43 #define GAMMA_FACTOR 1.04f
    44 #define GAMMA_MAX 100
    45 #define GAMMA(g) (((g) < 0) ? 1.0 / gammatab[-(g)] : gammatab[(g)])
    46 #define PAD_STEP 0.15
    47 
    48 /* libcucul/libcaca contexts */
    49 cucul_t *qq; caca_t *kk;
    50 
    51 /* Local functions */
    52 static void print_status(void);
    53 static void print_help(int, int);
    54 static void set_zoom(int);
    55 static void set_gamma(int);
    56 static void load_image(char const *);
    57 static void unload_image(void);
    58 static void draw_checkers(int, int, int, int);
     27#include "common-image.h"
     28
    5929#if !defined(HAVE_IMLIB2_H)
    6030static int freadint(FILE *);
     
    6333#endif
    6434
    65 /* Local variables */
     35struct image * load_image(char const * name)
     36{
     37    struct image * im = malloc(sizeof(struct image));
     38    unsigned int depth, bpp, rmask, gmask, bmask, amask;
     39
    6640#if defined(HAVE_IMLIB2_H)
    67 Imlib_Image image = NULL;
    68 #endif
    69 char *pixels = NULL;
    70 struct cucul_dither *dither = NULL;
    71 unsigned int w, h, depth, bpp, rmask, gmask, bmask, amask;
    72 #if !defined(HAVE_IMLIB2_H)
    73 unsigned int red[256], green[256], blue[256], alpha[256];
    74 #endif
    75 
    76 float zoomtab[ZOOM_MAX + 1];
    77 float gammatab[GAMMA_MAX + 1];
    78 float xfactor = 1.0, yfactor = 1.0, dx = 0.5, dy = 0.5;
    79 int zoom = 0, g = 0, fullscreen = 0, mode, ww, wh;
    80 
    81 int main(int argc, char **argv)
    82 {
    83     int quit = 0, update = 1, help = 0, status = 0;
    84     int reload = 0;
    85 
    86     char **list = NULL;
    87     int current = 0, items = 0, opts = 1;
    88     int i;
    89 
    90     /* Initialise libcucul */
    91     qq = cucul_create(0, 0);
    92     if(!qq)
    93     {
    94         fprintf(stderr, "%s: unable to initialise libcucul\n", argv[0]);
    95         return 1;
    96     }
    97 
    98     kk = caca_attach(qq);
    99     if(!kk)
    100     {
    101         fprintf(stderr, "%s: unable to initialise libcaca\n", argv[0]);
    102         return 1;
    103     }
    104 
    105     /* Set the window title */
    106     caca_set_window_title(kk, "cacaview");
    107 
    108     ww = cucul_get_width(qq);
    109     wh = cucul_get_height(qq);
    110 
    111     /* Fill the zoom table */
    112     zoomtab[0] = 1.0;
    113     for(i = 0; i < ZOOM_MAX; i++)
    114         zoomtab[i + 1] = zoomtab[i] * ZOOM_FACTOR;
    115 
    116     /* Fill the gamma table */
    117     gammatab[0] = 1.0;
    118     for(i = 0; i < GAMMA_MAX; i++)
    119         gammatab[i + 1] = gammatab[i] * GAMMA_FACTOR;
    120 
    121     /* Load items into playlist */
    122     for(i = 1; i < argc; i++)
    123     {
    124         /* Skip options except after `--' */
    125         if(opts && argv[i][0] == '-')
    126         {
    127             if(argv[i][1] == '-' && argv[i][2] == '\0')
    128                 opts = 0;
    129             continue;
    130         }
    131 
    132         /* Add argv[i] to the list */
    133         if(items)
    134             list = realloc(list, (items + 1) * sizeof(char *));
    135         else
    136             list = malloc(sizeof(char *));
    137         list[items] = argv[i];
    138         items++;
    139 
    140         reload = 1;
    141     }
    142 
    143     /* Go ! */
    144     while(!quit)
    145     {
    146         struct caca_event ev;
    147         unsigned int const event_mask = CACA_EVENT_KEY_PRESS
    148                                       | CACA_EVENT_RESIZE
    149                                       | CACA_EVENT_MOUSE_PRESS;
    150         unsigned int new_status = 0, new_help = 0;
    151         int event;
    152 
    153         if(update)
    154             event = caca_get_event(kk, event_mask, &ev, 0);
    155         else
    156             event = caca_get_event(kk, event_mask, &ev, -1);
    157 
    158         while(event)
    159         {
    160             if(ev.type & CACA_EVENT_MOUSE_PRESS)
    161             {
    162                 if(ev.data.mouse.button == 1)
    163                 {
    164                     if(items) current = (current + 1) % items;
    165                     reload = 1;
    166                 }
    167                 else if(ev.data.mouse.button == 2)
    168                 {
    169                     if(items) current = (items + current - 1) % items;
    170                     reload = 1;
    171                 }
    172             }
    173             else if(ev.type & CACA_EVENT_KEY_PRESS) switch(ev.data.key.c)
    174             {
    175             case 'n':
    176             case 'N':
    177                 if(items) current = (current + 1) % items;
    178                 reload = 1;
    179                 break;
    180             case 'p':
    181             case 'P':
    182                 if(items) current = (items + current - 1) % items;
    183                 reload = 1;
    184                 break;
    185             case 'f':
    186             case 'F':
    187                 fullscreen = ~fullscreen;
    188                 update = 1;
    189                 set_zoom(zoom);
    190                 break;
    191             case 'b':
    192                 i = 1 + cucul_get_feature(qq, CUCUL_BACKGROUND);
    193                 if(i > CUCUL_BACKGROUND_MAX) i = CUCUL_BACKGROUND_MIN;
    194                 cucul_set_feature(qq, i);
    195                 new_status = STATUS_BACKGROUND;
    196                 update = 1;
    197                 break;
    198             case 'B':
    199                 i = -1 + cucul_get_feature(qq, CUCUL_BACKGROUND);
    200                 if(i < CUCUL_BACKGROUND_MIN) i = CUCUL_BACKGROUND_MAX;
    201                 cucul_set_feature(qq, i);
    202                 new_status = STATUS_BACKGROUND;
    203                 update = 1;
    204                 break;
    205             case 'a':
    206                 i = 1 + cucul_get_feature(qq, CUCUL_ANTIALIASING);
    207                 if(i > CUCUL_ANTIALIASING_MAX) i = CUCUL_ANTIALIASING_MIN;
    208                 cucul_set_feature(qq, i);
    209                 new_status = STATUS_ANTIALIASING;
    210                 update = 1;
    211                 break;
    212             case 'A':
    213                 i = -1 + cucul_get_feature(qq, CUCUL_ANTIALIASING);
    214                 if(i < CUCUL_ANTIALIASING_MIN) i = CUCUL_ANTIALIASING_MAX;
    215                 cucul_set_feature(qq, i);
    216                 new_status = STATUS_ANTIALIASING;
    217                 update = 1;
    218                 break;
    219             case 'd':
    220                 i = 1 + cucul_get_feature(qq, CUCUL_DITHERING);
    221                 if(i > CUCUL_DITHERING_MAX) i = CUCUL_DITHERING_MIN;
    222                 cucul_set_feature(qq, i);
    223                 new_status = STATUS_DITHERING;
    224                 update = 1;
    225                 break;
    226             case 'D':
    227                 i = -1 + cucul_get_feature(qq, CUCUL_DITHERING);
    228                 if(i < CUCUL_DITHERING_MIN) i = CUCUL_DITHERING_MAX;
    229                 cucul_set_feature(qq, i);
    230                 new_status = STATUS_DITHERING;
    231                 update = 1;
    232                 break;
    233             case '+':
    234                 update = 1;
    235                 set_zoom(zoom + 1);
    236                 break;
    237             case '-':
    238                 update = 1;
    239                 set_zoom(zoom - 1);
    240                 break;
    241             case 'G':
    242                 update = 1;
    243                 set_gamma(g + 1);
    244                 break;
    245             case 'g':
    246                 update = 1;
    247                 set_gamma(g - 1);
    248                 break;
    249             case 'x':
    250             case 'X':
    251                 update = 1;
    252                 set_zoom(0);
    253                 set_gamma(0);
    254                 break;
    255             case 'k':
    256             case 'K':
    257             case CACA_KEY_UP:
    258                 if(yfactor > 1.0) dy -= PAD_STEP / yfactor;
    259                 if(dy < 0.0) dy = 0.0;
    260                 update = 1;
    261                 break;
    262             case 'j':
    263             case 'J':
    264             case CACA_KEY_DOWN:
    265                 if(yfactor > 1.0) dy += PAD_STEP / yfactor;
    266                 if(dy > 1.0) dy = 1.0;
    267                 update = 1;
    268                 break;
    269             case 'h':
    270             case 'H':
    271             case CACA_KEY_LEFT:
    272                 if(xfactor > 1.0) dx -= PAD_STEP / xfactor;
    273                 if(dx < 0.0) dx = 0.0;
    274                 update = 1;
    275                 break;
    276             case 'l':
    277             case 'L':
    278             case CACA_KEY_RIGHT:
    279                 if(xfactor > 1.0) dx += PAD_STEP / xfactor;
    280                 if(dx > 1.0) dx = 1.0;
    281                 update = 1;
    282                 break;
    283             case '?':
    284                 new_help = !help;
    285                 update = 1;
    286                 break;
    287             case 'q':
    288             case 'Q':
    289                 quit = 1;
    290                 break;
    291             }
    292             else if(ev.type == CACA_EVENT_RESIZE)
    293             {
    294                 caca_display(kk);
    295                 ww = ev.data.resize.w;
    296                 wh = ev.data.resize.h;
    297                 update = 1;
    298                 set_zoom(zoom);
    299             }
    300 
    301             if(status || new_status)
    302                 status = new_status;
    303 
    304             if(help || new_help)
    305                 help = new_help;
    306 
    307             event = caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0);
    308         }
    309 
    310         if(items && reload)
    311         {
    312             char *buffer;
    313             int len = strlen(" Loading `%s'... ") + strlen(list[current]);
    314 
    315             if(len < ww + 1)
    316                 len = ww + 1;
    317 
    318             buffer = malloc(len);
    319 
    320             sprintf(buffer, " Loading `%s'... ", list[current]);
    321             buffer[ww] = '\0';
    322             cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    323             cucul_putstr(qq, (ww - strlen(buffer)) / 2, wh / 2, buffer);
    324             caca_display(kk);
    325             ww = cucul_get_width(qq);
    326             wh = cucul_get_height(qq);
    327 
    328             unload_image();
    329             load_image(list[current]);
    330             reload = 0;
    331 
    332             /* Reset image-specific runtime variables */
    333             dx = dy = 0.5;
    334             update = 1;
    335             set_zoom(0);
    336             set_gamma(0);
    337 
    338             free(buffer);
    339         }
    340 
    341         cucul_clear(qq);
    342 
    343         if(!items)
    344         {
    345             cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    346             cucul_printf(qq, ww / 2 - 5, wh / 2, " No image. ");
    347         }
    348         else if(!pixels)
    349         {
    350 #if defined(HAVE_IMLIB2_H)
    351 #   define ERROR_STRING " Error loading `%s'. "
    352 #else
    353 #   define ERROR_STRING " Error loading `%s'. Only BMP is supported. "
    354 #endif
    355             char *buffer;
    356             int len = strlen(ERROR_STRING) + strlen(list[current]);
    357 
    358             if(len < ww + 1)
    359                 len = ww + 1;
    360 
    361             buffer = malloc(len);
    362 
    363             sprintf(buffer, ERROR_STRING, list[current]);
    364             buffer[ww] = '\0';
    365             cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    366             cucul_putstr(qq, (ww - strlen(buffer)) / 2, wh / 2, buffer);
    367             free(buffer);
    368         }
    369         else
    370         {
    371             float xdelta, ydelta;
    372             int y, height;
    373 
    374             y = fullscreen ? 0 : 1;
    375             height = fullscreen ? wh : wh - 3;
    376 
    377             xdelta = (xfactor > 1.0) ? dx : 0.5;
    378             ydelta = (yfactor > 1.0) ? dy : 0.5;
    379 
    380             draw_checkers(ww * (1.0 - xfactor) / 2,
    381                           y + height * (1.0 - yfactor) / 2,
    382                           ww * (1.0 + xfactor) / 2,
    383                           y + height * (1.0 + yfactor) / 2);
    384 
    385             cucul_dither_bitmap(qq, ww * (1.0 - xfactor) * xdelta,
    386                               y + height * (1.0 - yfactor) * ydelta,
    387                               ww * (xdelta + (1.0 - xdelta) * xfactor),
    388                               y + height * (ydelta + (1.0 - ydelta) * yfactor),
    389                               dither, pixels);
    390         }
    391 
    392         if(!fullscreen)
    393         {
    394             print_status();
    395 
    396             cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    397             switch(status)
    398             {
    399                 case STATUS_ANTIALIASING:
    400                     cucul_printf(qq, 0, wh - 1, "Antialiasing: %s",
    401                   cucul_get_feature_name(cucul_get_feature(qq, CUCUL_ANTIALIASING)));
    402                     break;
    403                 case STATUS_DITHERING:
    404                     cucul_printf(qq, 0, wh - 1, "Dithering: %s",
    405                   cucul_get_feature_name(cucul_get_feature(qq, CUCUL_DITHERING)));
    406                     break;
    407                 case STATUS_BACKGROUND:
    408                     cucul_printf(qq, 0, wh - 1, "Background: %s",
    409                   cucul_get_feature_name(cucul_get_feature(qq, CUCUL_BACKGROUND)));
    410                     break;
    411             }
    412         }
    413 
    414         if(help)
    415         {
    416             print_help(ww - 26, 2);
    417         }
    418 
    419         caca_display(kk);
    420         update = 0;
    421     }
    422 
    423     /* Clean up */
    424     unload_image();
    425     caca_detach(kk);
    426     cucul_free(qq);
    427 
    428     return 0;
    429 }
    430 
    431 static void print_status(void)
    432 {
    433     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    434     cucul_draw_line(qq, 0, 0, ww - 1, 0, " ");
    435     cucul_draw_line(qq, 0, wh - 2, ww - 1, wh - 2, "-");
    436     cucul_putstr(qq, 0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  gG:Gamma  "
    437                            "hjkl:Move  d:Dither  a:Antialias");
    438     cucul_putstr(qq, ww - strlen("?:Help"), 0, "?:Help");
    439     cucul_printf(qq, 3, wh - 2, "cacaview %s", VERSION);
    440     cucul_printf(qq, ww - 30, wh - 2, "(gamma: %#.3g)", GAMMA(g));
    441     cucul_printf(qq, ww - 14, wh - 2, "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
    442 
    443     cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
    444     cucul_draw_line(qq, 0, wh - 1, ww - 1, wh - 1, " ");
    445 }
    446 
    447 static void print_help(int x, int y)
    448 {
    449     static char const *help[] =
    450     {
    451         " +: zoom in              ",
    452         " -: zoom out             ",
    453         " g: decrease gamma       ",
    454         " G: increase gamma       ",
    455         " x: reset zoom and gamma ",
    456         " ----------------------- ",
    457         " hjkl: move view         ",
    458         " arrows: move view       ",
    459         " ----------------------- ",
    460         " a: antialiasing method  ",
    461         " d: dithering method     ",
    462         " b: background mode      ",
    463         " ----------------------- ",
    464         " ?: help                 ",
    465         " q: quit                 ",
    466         NULL
    467     };
    468 
    469     int i;
    470 
    471     cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    472 
    473     for(i = 0; help[i]; i++)
    474         cucul_putstr(qq, x, y + i, help[i]);
    475 }
    476 
    477 static void set_zoom(int new_zoom)
    478 {
    479     int height;
    480 
    481     zoom = new_zoom;
    482 
    483     if(zoom > ZOOM_MAX) zoom = ZOOM_MAX;
    484     if(zoom < -ZOOM_MAX) zoom = -ZOOM_MAX;
    485 
    486     ww = cucul_get_width(qq);
    487     height = fullscreen ? wh : wh - 3;
    488 
    489     xfactor = (zoom < 0) ? 1.0 / zoomtab[-zoom] : zoomtab[zoom];
    490     yfactor = xfactor * ww / height * h / w
    491                * cucul_get_height(qq) / cucul_get_width(qq)
    492                * caca_get_window_width(kk) / caca_get_window_height(kk);
    493 
    494     if(yfactor > xfactor)
    495     {
    496         float tmp = xfactor;
    497         xfactor = tmp * tmp / yfactor;
    498         yfactor = tmp;
    499     }
    500 }
    501 
    502 static void set_gamma(int new_gamma)
    503 {
    504     g = new_gamma;
    505 
    506     if(g > GAMMA_MAX) g = GAMMA_MAX;
    507     if(g < -GAMMA_MAX) g = -GAMMA_MAX;
    508 
    509     cucul_set_dither_gamma(dither, (g < 0) ? 1.0 / gammatab[-g] : gammatab[g]);
    510 }
    511 
    512 static void unload_image(void)
    513 {
    514 #if defined(HAVE_IMLIB2_H)
    515     if(image)
    516         imlib_free_image();
    517     image = NULL;
    518     pixels = NULL;
    519 #else
    520     if(pixels)
    521         free(pixels);
    522     pixels = NULL;
    523 #endif
    524     if(dither)
    525         cucul_free_dither(dither);
    526     dither = NULL;
    527 }
    528 
    529 static void load_image(char const *name)
    530 {
    531 #if defined(HAVE_IMLIB2_H)
     41    Imlib_Image image;
     42
    53243    /* Load the new image */
    53344    image = imlib_load_image(name);
    53445
    53546    if(!image)
    536         return;
     47    {
     48        free(im);
     49        return NULL;
     50    }
    53751
    53852    imlib_context_set_image(image);
    539     pixels = (char *)imlib_image_get_data_for_reading_only();
    540     w = imlib_image_get_width();
    541     h = imlib_image_get_height();
     53    im->pixels = (char *)imlib_image_get_data_for_reading_only();
     54    im->w = imlib_image_get_width();
     55    im->h = imlib_image_get_height();
    54256    rmask = 0x00ff0000;
    54357    gmask = 0x0000ff00;
     
    54862
    54963    /* Create the libcucul dither */
    550     dither = cucul_create_dither(bpp, w, h, depth * w,
    551                                  rmask, gmask, bmask, amask);
    552     if(!dither)
     64    im->dither = cucul_create_dither(bpp, im->w, im->h, depth * im->w,
     65                                     rmask, gmask, bmask, amask);
     66    if(!im->dither)
    55367    {
    55468        imlib_free_image();
    555         image = NULL;
    556     }
     69        free(im);
     70        return NULL;
     71    }
     72
     73    im->priv = (void *)image;
    55774
    55875#else
    55976    /* Try to load a BMP file */
     77    unsigned int red[256], green[256], blue[256], alpha[256];
     78    unsigned int i, colors, offset, tmp, planes;
    56079    FILE *fp;
    561     unsigned int i, colors, offset, tmp, planes;
    56280
    56381    fp = fopen(name, "rb");
    56482    if(!fp)
    565         return;
     83    {
     84        free(im);
     85        return NULL;
     86    }
    56687
    56788    if(freadshort(fp) != 0x4d42)
    56889    {
    56990        fclose(fp);
    570         return;
     91        free(im);
     92        return NULL;
    57193    }
    57294
     
    580102    if(tmp == 40)
    581103    {
    582         w = freadint(fp);
    583         h = freadint(fp);
     104        im->w = freadint(fp);
     105        im->h = freadint(fp);
    584106        planes = freadshort(fp);
    585107        bpp = freadshort(fp);
     
    589111        {
    590112            fclose(fp);
    591             return;
     113            free(im);
     114            return NULL;
    592115        }
    593116
     
    610133    else if(tmp == 12)
    611134    {
    612         w = freadint(fp);
    613         h = freadint(fp);
     135        im->w = freadint(fp);
     136        im->h = freadint(fp);
    614137        planes = freadshort(fp);
    615138        bpp = freadshort(fp);
     
    627150    {
    628151        fclose(fp);
    629         return;
     152        free(im);
     153        return NULL;
    630154    }
    631155
     
    637161
    638162    /* Sanity check */
    639     if(!w || w > 0x10000 || !h || h > 0x10000 || planes != 1 /*|| bpp != 24*/)
    640     {
    641         fclose(fp);
    642         return;
     163    if(!im->w || im->w > 0x10000 || !im->h || im->h > 0x10000 || planes != 1)
     164    {
     165        fclose(fp);
     166        free(im);
     167        return NULL;
    643168    }
    644169
    645170    /* Allocate the pixel buffer */
    646     pixels = malloc(w * h * depth);
    647     if(!pixels)
    648     {
    649         fclose(fp);
    650         return;
    651     }
    652 
    653     memset(pixels, 0, w * h * depth);
    654 
    655     /* Read the dither data */
    656     for(i = h; i--; )
     171    im->pixels = malloc(im->w * im->h * depth);
     172    if(!im->pixels)
     173    {
     174        fclose(fp);
     175        free(im);
     176        return NULL;
     177    }
     178
     179    memset(im->pixels, 0, im->w * im->h * depth);
     180
     181    /* Read the bitmap data */
     182    for(i = im->h; i--; )
    657183    {
    658184        unsigned int j, k, bits = 0;
     
    661187        {
    662188            case 1:
    663                 for(j = 0; j < w; j++)
     189                for(j = 0; j < im->w; j++)
    664190                {
    665191                    k = j % 32;
    666192                    if(k == 0)
    667193                        bits = freadint(fp);
    668                     pixels[w * i * depth + j] =
     194                    im->pixels[im->w * i * depth + j] =
    669195                        (bits >> ((k & ~0xf) + 0xf - (k & 0xf))) & 0x1;
    670196                }
    671197                break;
    672198            case 4:
    673                 for(j = 0; j < w; j++)
     199                for(j = 0; j < im->w; j++)
    674200                {
    675201                    k = j % 8;
    676202                    if(k == 0)
    677203                        bits = freadint(fp);
    678                     pixels[w * i * depth + j] =
     204                    im->pixels[im->w * i * depth + j] =
    679205                        (bits >> (4 * ((k & ~0x1) + 0x1 - (k & 0x1)))) & 0xf;
    680206                }
     
    682208            default:
    683209                /* Works for 8bpp, but also for 16, 24 etc. */
    684                 fread(pixels + w * i * depth, w * depth, 1, fp);
     210                fread(im->pixels + im->w * i * depth, im->w * depth, 1, fp);
    685211                /* Pad reads to 4 bytes */
    686                 tmp = (w * depth) % 4;
     212                tmp = (im->w * depth) % 4;
    687213                tmp = (4 - tmp) % 4;
    688214                while(tmp--)
     
    716242
    717243    /* Create the libcucul dither */
    718     dither = cucul_create_dither(bpp, w, h, depth * w,
    719                                  rmask, gmask, bmask, amask);
    720     if(!dither)
    721     {
    722         free(pixels);
    723         pixels = NULL;
    724         return;
     244    im->dither = cucul_create_dither(bpp, im->w, im->h, depth * im->w,
     245                                     rmask, gmask, bmask, amask);
     246    if(!im->dither)
     247    {
     248        free(im->pixels);
     249        free(im);
     250        return NULL;
    725251    }
    726252
    727253    if(bpp == 8)
    728         cucul_set_dither_palette(dither, red, green, blue, alpha);
    729 #endif
    730 }
    731 
    732 static void draw_checkers(int x1, int y1, int x2, int y2)
    733 {
    734     int xn, yn;
    735 
    736     if(x2 + 1 > (int)cucul_get_width(qq)) x2 = cucul_get_width(qq) - 1;
    737     if(y2 + 1 > (int)cucul_get_height(qq)) y2 = cucul_get_height(qq) - 1;
    738 
    739     for(yn = y1 > 0 ? y1 : 0; yn <= y2; yn++)
    740         for(xn = x1 > 0 ? x1 : 0; xn <= x2; xn++)
    741     {
    742         if((((xn - x1) / 5) ^ ((yn - y1) / 3)) & 1)
    743             cucul_set_color(qq, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_DARKGRAY);
    744         else
    745             cucul_set_color(qq, CUCUL_COLOR_DARKGRAY, CUCUL_COLOR_LIGHTGRAY);
    746         cucul_putchar(qq, xn, yn, ' ');
    747     }
     254        cucul_set_dither_palette(im->dither, red, green, blue, alpha);
     255#endif
     256
     257    return im;
     258}
     259
     260void unload_image(struct image * im)
     261{
     262#if defined(HAVE_IMLIB2_H)
     263    /* Imlib_Image image = (Imlib_Image)im->priv; */
     264    imlib_free_image();
     265#else
     266    free(im->pixels);
     267#endif
     268    cucul_free_dither(im->dither);
    748269}
    749270
Note: See TracChangeset for help on using the changeset viewer.