Ignore:
Timestamp:
Sep 27, 2008, 3:12:46 PM (12 years ago)
Author:
Sam Hocevar
Message:

Starting refactoring to get rid of libcucul. The initial reason for the
split is rendered moot by the plugin system: when enabled, binaries do
not link directly with libX11 or libGL. I hope this is a step towards
more consisteny and clarity.

Location:
libcaca/trunk/src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/src/Makefile.am

    r2299 r2821  
    44
    55EXTRA_DIST = caca.txt
    6 AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/cucul -I../cucul \
     6AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/caca -I../caca \
    77              -I$(top_srcdir)/caca -DLIBCACA=1 -DX_DISPLAY_MISSING=1
    88
     
    1111
    1212cacademo_SOURCES = cacademo.c texture.h
    13 cacademo_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     13cacademo_LDADD = ../caca/libcaca.la ../caca/libcaca.la
    1414cacademo_LDFLAGS = @MATH_LIBS@
    1515
    1616cacafire_SOURCES = aafire.c
    17 cacafire_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     17cacafire_LDADD = ../caca/libcaca.la ../caca/libcaca.la
    1818
    1919cacaview_SOURCES = cacaview.c common-image.c common-image.h
    20 cacaview_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     20cacaview_LDADD = ../caca/libcaca.la ../caca/libcaca.la
    2121cacaview_CFLAGS = $(IMLIB2_CFLAGS)
    2222cacaview_LDFLAGS = $(IMLIB2_LIBS)
    2323
    2424cacadraw_SOURCES = cacadraw.c
    25 cacadraw_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     25cacadraw_LDADD = ../caca/libcaca.la ../caca/libcaca.la
    2626
    2727cacaplay_SOURCES = cacaplay.c
    28 cacaplay_LDADD = ../caca/libcaca.la ../cucul/libcucul.la
     28cacaplay_LDADD = ../caca/libcaca.la ../caca/libcaca.la
    2929
    3030cacaserver_SOURCES = cacaserver.c
    31 cacaserver_LDADD = ../cucul/libcucul.la
     31cacaserver_LDADD = ../caca/libcaca.la
    3232
    3333img2txt_SOURCES = img2txt.c $(GETOPT) common-image.c common-image.h
    34 img2txt_LDADD = ../cucul/libcucul.la
     34img2txt_LDADD = ../caca/libcaca.la
    3535img2txt_CFLAGS = $(IMLIB2_CFLAGS)
    3636img2txt_LDFLAGS = $(IMLIB2_LIBS) $(GETOPT_LIBS)
  • libcaca/trunk/src/aafire.c

    r2304 r2821  
    3030#   include <string.h>
    3131#endif
    32 #include "cucul.h"
    3332#include "caca.h"
    3433#else
     
    4140#define MAXTABLE (256*5)
    4241#ifdef LIBCACA
    43 static cucul_canvas_t *cv;
     42static caca_canvas_t *cv;
    4443static caca_display_t *dp;
    4544static int XSIZ, YSIZ;
    46 static cucul_dither_t *cucul_dither;
     45static caca_dither_t *caca_dither;
    4746static char *bitmap;
    4847static int paused = 0;
     
    102101
    103102#ifdef LIBCACA
    104   cv = cucul_create_canvas(80, 32);
     103  cv = caca_create_canvas(80, 32);
    105104  if (!cv)
    106105    {
    107       printf ("Failed to initialize libcucul\n");
     106      printf ("Failed to initialize libcaca\n");
    108107      exit (1);
    109108    }
     
    115114    }
    116115  caca_set_display_time(dp, 10000);
    117   XSIZ = cucul_get_canvas_width(cv) * 2;
    118   YSIZ = cucul_get_canvas_height(cv) * 2 - 4;
     116  XSIZ = caca_get_canvas_width(cv) * 2;
     117  YSIZ = caca_get_canvas_height(cv) * 2 - 4;
    119118#else
    120119  context = aa_autoinit (&aa_defparams);
     
    142141
    143142#ifdef LIBCACA
    144   cucul_dither = cucul_create_dither(8, XSIZ, YSIZ - 2, XSIZ, 0, 0, 0, 0);
    145   cucul_set_dither_palette(cucul_dither, r, g, b, a);
    146   bitmap = malloc(4 * cucul_get_canvas_width(cv)
    147                     * cucul_get_canvas_height(cv));
    148   memset(bitmap, 0, 4 * cucul_get_canvas_width(cv)
    149                       * cucul_get_canvas_height(cv));
     143  caca_dither = caca_create_dither(8, XSIZ, YSIZ - 2, XSIZ, 0, 0, 0, 0);
     144  caca_set_dither_palette(caca_dither, r, g, b, a);
     145  bitmap = malloc(4 * caca_get_canvas_width(cv)
     146                    * caca_get_canvas_height(cv));
     147  memset(bitmap, 0, 4 * caca_get_canvas_width(cv)
     148                      * caca_get_canvas_height(cv));
    150149#else
    151150  aa_hidecursor (context);
     
    157156#ifdef LIBCACA
    158157  caca_free_display(dp);
    159   cucul_free_canvas(cv);
     158  caca_free_canvas(cv);
    160159#else
    161160  aa_close (context);
     
    239238#ifdef LIBCACA
    240239_paused:
    241   cucul_dither_bitmap(cv, 0, 0, cucul_get_canvas_width(cv),
    242                       cucul_get_canvas_height(cv), cucul_dither, bitmap);
    243   cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
     240  caca_dither_bitmap(cv, 0, 0, caca_get_canvas_width(cv),
     241                      caca_get_canvas_height(cv), caca_dither, bitmap);
     242  caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
    244243  if (sloop < 100)
    245     cucul_put_str(cv, cucul_get_canvas_width(cv) - 30,
    246                   cucul_get_canvas_height(cv) - 2,
     244    caca_put_str(cv, caca_get_canvas_width(cv) - 30,
     245                  caca_get_canvas_height(cv) - 2,
    247246                  " -=[ Powered by libcaca ]=- ");
    248247 
  • libcaca/trunk/src/cacademo.c

    r2399 r2821  
    2727#endif
    2828
    29 #include "cucul.h"
    3029#include "caca.h"
    3130
    3231enum action { PREPARE, INIT, UPDATE, RENDER, FREE };
    3332
    34 void transition(cucul_canvas_t *, int, int);
    35 void plasma(enum action, cucul_canvas_t *);
    36 void metaballs(enum action, cucul_canvas_t *);
    37 void moire(enum action, cucul_canvas_t *);
    38 void langton(enum action, cucul_canvas_t *);
    39 void matrix(enum action, cucul_canvas_t *);
    40 void rotozoom(enum action, cucul_canvas_t *);
    41 
    42 void (*fn[])(enum action, cucul_canvas_t *) =
     33void transition(caca_canvas_t *, int, int);
     34void plasma(enum action, caca_canvas_t *);
     35void metaballs(enum action, caca_canvas_t *);
     36void moire(enum action, caca_canvas_t *);
     37void langton(enum action, caca_canvas_t *);
     38void matrix(enum action, caca_canvas_t *);
     39void rotozoom(enum action, caca_canvas_t *);
     40
     41void (*fn[])(enum action, caca_canvas_t *) =
    4342{
    4443    plasma,
     
    5150#define DEMOS (sizeof(fn)/sizeof(*fn))
    5251
    53 #define DEMO_FRAMES cucul_rand(500, 1000)
     52#define DEMO_FRAMES caca_rand(500, 1000)
    5453#define TRANSITION_FRAMES 40
    5554
     
    7170{
    7271    static caca_display_t *dp;
    73     static cucul_canvas_t *frontcv, *backcv, *mask;
     72    static caca_canvas_t *frontcv, *backcv, *mask;
    7473
    7574    int demo, next = -1, paused = 0, next_transition = DEMO_FRAMES;
    7675    unsigned int i;
    77     int tmode = cucul_rand(0, TRANSITION_COUNT);
     76    int tmode = caca_rand(0, TRANSITION_COUNT);
    7877
    7978    /* Set up two canvases, a mask, and attach a display to the front one */
    80     frontcv = cucul_create_canvas(0, 0);
    81     backcv = cucul_create_canvas(0, 0);
    82     mask = cucul_create_canvas(0, 0);
     79    frontcv = caca_create_canvas(0, 0);
     80    backcv = caca_create_canvas(0, 0);
     81    mask = caca_create_canvas(0, 0);
    8382
    8483    dp = caca_create_display(frontcv);
     
    8685        return 1;
    8786
    88     cucul_set_canvas_size(backcv, cucul_get_canvas_width(frontcv),
    89                                   cucul_get_canvas_height(frontcv));
    90     cucul_set_canvas_size(mask, cucul_get_canvas_width(frontcv),
    91                                 cucul_get_canvas_height(frontcv));
     87    caca_set_canvas_size(backcv, caca_get_canvas_width(frontcv),
     88                                  caca_get_canvas_height(frontcv));
     89    caca_set_canvas_size(mask, caca_get_canvas_width(frontcv),
     90                                caca_get_canvas_height(frontcv));
    9291
    9392    caca_set_display_time(dp, 20000);
     
    9897
    9998    /* Choose a demo at random */
    100     demo = cucul_rand(0, DEMOS);
     99    demo = caca_rand(0, DEMOS);
    101100    fn[demo](INIT, frontcv);
    102101
     
    128127
    129128        /* Resize the spare canvas, just in case the main one changed */
    130         cucul_set_canvas_size(backcv, cucul_get_canvas_width(frontcv),
    131                                       cucul_get_canvas_height(frontcv));
    132         cucul_set_canvas_size(mask, cucul_get_canvas_width(frontcv),
    133                                     cucul_get_canvas_height(frontcv));
     129        caca_set_canvas_size(backcv, caca_get_canvas_width(frontcv),
     130                                      caca_get_canvas_height(frontcv));
     131        caca_set_canvas_size(mask, caca_get_canvas_width(frontcv),
     132                                    caca_get_canvas_height(frontcv));
    134133
    135134        if(paused)
     
    142141        if(frame == next_transition)
    143142        {
    144             next = cucul_rand(0, DEMOS);
     143            next = caca_rand(0, DEMOS);
    145144            if(next == demo)
    146145                next = (next + 1) % DEMOS;
     
    153152            next = -1;
    154153            next_transition = frame + DEMO_FRAMES;
    155             tmode = cucul_rand(0, TRANSITION_COUNT);
     154            tmode = caca_rand(0, TRANSITION_COUNT);
    156155        }
    157156
     
    168167        {
    169168            fn[next](RENDER, backcv);
    170             cucul_set_color_ansi(mask, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    171             cucul_clear_canvas(mask);
    172             cucul_set_color_ansi(mask, CUCUL_WHITE, CUCUL_WHITE);
     169            caca_set_color_ansi(mask, CACA_LIGHTGRAY, CACA_BLACK);
     170            caca_clear_canvas(mask);
     171            caca_set_color_ansi(mask, CACA_WHITE, CACA_WHITE);
    173172            transition(mask, tmode,
    174173                       100 * (frame - next_transition) / TRANSITION_FRAMES);
    175             cucul_blit(frontcv, 0, 0, backcv, mask);
    176         }
    177 
    178         cucul_set_color_ansi(frontcv, CUCUL_WHITE, CUCUL_BLUE);
     174            caca_blit(frontcv, 0, 0, backcv, mask);
     175        }
     176
     177        caca_set_color_ansi(frontcv, CACA_WHITE, CACA_BLUE);
    179178        if(frame < 100)
    180             cucul_put_str(frontcv, cucul_get_canvas_width(frontcv) - 30,
    181                                    cucul_get_canvas_height(frontcv) - 2,
     179            caca_put_str(frontcv, caca_get_canvas_width(frontcv) - 30,
     180                                   caca_get_canvas_height(frontcv) - 2,
    182181                                   " -=[ Powered by libcaca ]=- ");
    183182        caca_refresh_display(dp);
     
    189188
    190189    caca_free_display(dp);
    191     cucul_free_canvas(mask);
    192     cucul_free_canvas(backcv);
    193     cucul_free_canvas(frontcv);
     190    caca_free_canvas(mask);
     191    caca_free_canvas(backcv);
     192    caca_free_canvas(frontcv);
    194193
    195194    return 0;
     
    197196
    198197/* Transitions */
    199 void transition(cucul_canvas_t *mask, int tmode, int completed)
     198void transition(caca_canvas_t *mask, int tmode, int completed)
    200199{
    201200    static float const star[] =
     
    224223    static float square_rot[sizeof(square)/sizeof(*square)];
    225224
    226     float mulx = 0.0075f * completed * cucul_get_canvas_width(mask);
    227     float muly = 0.0075f * completed * cucul_get_canvas_height(mask);
    228     int w2 = cucul_get_canvas_width(mask) / 2;
    229     int h2 = cucul_get_canvas_height(mask) / 2;
     225    float mulx = 0.0075f * completed * caca_get_canvas_width(mask);
     226    float muly = 0.0075f * completed * caca_get_canvas_height(mask);
     227    int w2 = caca_get_canvas_width(mask) / 2;
     228    int h2 = caca_get_canvas_height(mask) / 2;
    230229    float angle = (0.0075f * completed * 360) * 3.14 / 180, x, y;
    231230    unsigned int i;
    232     int w = cucul_get_canvas_width(mask);
    233     int h = cucul_get_canvas_height(mask);
     231    int w = caca_get_canvas_width(mask);
     232    int h = caca_get_canvas_height(mask);
    234233
    235234    switch(tmode)
     
    248247            mulx *= 1.8;
    249248            muly *= 1.8;
    250             cucul_fill_triangle(mask,
     249            caca_fill_triangle(mask,
    251250                                square_rot[0*2] * mulx + w2, square_rot[0*2+1] * muly + h2, \
    252251                                square_rot[1*2] * mulx + w2, square_rot[1*2+1] * muly + h2, \
    253252                                square_rot[2*2] * mulx + w2, square_rot[2*2+1] * muly + h2, '#');
    254             cucul_fill_triangle(mask,
     253            caca_fill_triangle(mask,
    255254                                square_rot[0*2] * mulx + w2, square_rot[0*2+1] * muly + h2, \
    256255                                square_rot[2*2] * mulx + w2, square_rot[2*2+1] * muly + h2, \
     
    274273
    275274#define DO_TRI(a, b, c) \
    276     cucul_fill_triangle(mask, \
     275    caca_fill_triangle(mask, \
    277276        star_rot[(a)*2] * mulx + w2, star_rot[(a)*2+1] * muly + h2, \
    278277        star_rot[(b)*2] * mulx + w2, star_rot[(b)*2+1] * muly + h2, \
     
    289288
    290289        case TRANSITION_CIRCLE:
    291             cucul_fill_ellipse(mask, w2, h2, mulx, muly, '#');
     290            caca_fill_ellipse(mask, w2, h2, mulx, muly, '#');
    292291            break;
    293292
     
    296295            {
    297296                int z = ((i & 1) ? w : (-w)/2) * (100 - completed) / 100;
    298                 cucul_fill_box(mask, i * w / 8, z ,  (w / 8) + 1, z + h, '#');
     297                caca_fill_box(mask, i * w / 8, z ,  (w / 8) + 1, z + h, '#');
    299298            }
    300299            break;
     
    305304            {
    306305                int z = ((i & 1) ? w : (-w)/2) * (100 - completed) / 100;
    307                 cucul_fill_box(mask, z, i * h / 6, z + w, (h / 6) + 1, '#');
     306                caca_fill_box(mask, z, i * h / 6, z + w, (h / 6) + 1, '#');
    308307            }
    309308            break;
     
    319318                      double, double, double, double, double, double);
    320319
    321 void plasma(enum action action, cucul_canvas_t *cv)
    322 {
    323     static cucul_dither_t *dither;
     320void plasma(enum action action, caca_canvas_t *cv)
     321{
     322    static caca_dither_t *dither;
    324323    static uint8_t *screen;
    325324    static uint32_t red[256], green[256], blue[256], alpha[256];
     
    336335
    337336        for(i = 0; i < 3; i++)
    338             r[i] = (double)(cucul_rand(1, 1000)) / 60000 * M_PI;
     337            r[i] = (double)(caca_rand(1, 1000)) / 60000 * M_PI;
    339338
    340339        for(i = 0; i < 6; i++)
    341             R[i] = (double)(cucul_rand(1, 1000)) / 10000;
     340            R[i] = (double)(caca_rand(1, 1000)) / 10000;
    342341
    343342        for(y = 0 ; y < TABLEY ; y++)
     
    354353    case INIT:
    355354        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
    356         dither = cucul_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
     355        dither = caca_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
    357356        break;
    358357
     
    368367
    369368        /* Set the palette */
    370         cucul_set_dither_palette(dither, red, green, blue, alpha);
     369        caca_set_dither_palette(dither, red, green, blue, alpha);
    371370
    372371        do_plasma(screen,
     
    380379
    381380    case RENDER:
    382         cucul_dither_bitmap(cv, 0, 0,
    383                             cucul_get_canvas_width(cv),
    384                             cucul_get_canvas_height(cv),
     381        caca_dither_bitmap(cv, 0, 0,
     382                            caca_get_canvas_width(cv),
     383                            caca_get_canvas_height(cv),
    385384                            dither, screen);
    386385        break;
     
    388387    case FREE:
    389388        free(screen);
    390         cucul_free_dither(dither);
     389        caca_free_dither(dither);
    391390        break;
    392391    }
     
    426425static void draw_ball(uint8_t *, unsigned int, unsigned int);
    427426
    428 void metaballs(enum action action, cucul_canvas_t *cv)
    429 {
    430     static cucul_dither_t *cucul_dither;
     427void metaballs(enum action action, caca_canvas_t *cv)
     428{
     429    static caca_dither_t *caca_dither;
    431430    static uint8_t *screen;
    432431    static uint32_t r[256], g[256], b[256], a[256];
     
    452451        for(n = 0; n < METABALLS; n++)
    453452        {
    454             dd[n] = cucul_rand(0, 100);
    455             di[n] = (float)cucul_rand(500, 4000) / 6000.0;
    456             dj[n] = (float)cucul_rand(500, 4000) / 6000.0;
    457             dk[n] = (float)cucul_rand(500, 4000) / 6000.0;
    458         }
    459 
    460         angleoff = cucul_rand(0, 360);
     453            dd[n] = caca_rand(0, 100);
     454            di[n] = (float)caca_rand(500, 4000) / 6000.0;
     455            dj[n] = (float)caca_rand(500, 4000) / 6000.0;
     456            dk[n] = (float)caca_rand(500, 4000) / 6000.0;
     457        }
     458
     459        angleoff = caca_rand(0, 360);
    461460
    462461        for(n = 0; n < 360 + 80; n++)
     
    466465    case INIT:
    467466        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
    468         /* Create a libcucul dither smaller than our pixel buffer, so that we
     467        /* Create a libcaca dither smaller than our pixel buffer, so that we
    469468         * display only the interesting part of it */
    470         cucul_dither = cucul_create_dither(8, XSIZ - METASIZE, YSIZ - METASIZE,
     469        caca_dither = caca_create_dither(8, XSIZ - METASIZE, YSIZ - METASIZE,
    471470                                           XSIZ, 0, 0, 0, 0);
    472471        break;
     
    493492
    494493        /* Set the palette */
    495         cucul_set_dither_palette(cucul_dither, r, g, b, a);
     494        caca_set_dither_palette(caca_dither, r, g, b, a);
    496495
    497496        /* Silly paths for our balls */
     
    517516
    518517    case RENDER:
    519         cucul_dither_bitmap(cv, 0, 0,
    520                           cucul_get_canvas_width(cv),
    521                           cucul_get_canvas_height(cv),
    522                           cucul_dither, screen + (METASIZE / 2) * (1 + XSIZ));
     518        caca_dither_bitmap(cv, 0, 0,
     519                          caca_get_canvas_width(cv),
     520                          caca_get_canvas_height(cv),
     521                          caca_dither, screen + (METASIZE / 2) * (1 + XSIZ));
    523522        break;
    524523
    525524    case FREE:
    526525        free(screen);
    527         cucul_free_dither(cucul_dither);
     526        caca_free_dither(caca_dither);
    528527        break;
    529528    }
     
    577576static void draw_line(int, int, char);
    578577
    579 void moire(enum action action, cucul_canvas_t *cv)
    580 {
    581     static cucul_dither_t *dither;
     578void moire(enum action action, caca_canvas_t *cv)
     579{
     580    static caca_dither_t *dither;
    582581    static uint8_t *screen;
    583582    static float d[6];
     
    594593
    595594        for(i = 0; i < 6; i++)
    596             d[i] = ((float)cucul_rand(50, 70)) / 1000.0;
     595            d[i] = ((float)caca_rand(50, 70)) / 1000.0;
    597596
    598597        red[0] = green[0] = blue[0] = 0x777;
     
    617616    case INIT:
    618617        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
    619         dither = cucul_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
     618        dither = caca_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
    620619        break;
    621620
     
    632631        blue[1] = 0.5 * (1 + cos(d[5] * (frame + 4000))) * 0xfff;
    633632
    634         cucul_set_dither_palette(dither, red, green, blue, alpha);
     633        caca_set_dither_palette(dither, red, green, blue, alpha);
    635634
    636635        /* Draw circles */
     
    645644
    646645    case RENDER:
    647         cucul_dither_bitmap(cv, 0, 0,
    648                             cucul_get_canvas_width(cv),
    649                             cucul_get_canvas_height(cv),
     646        caca_dither_bitmap(cv, 0, 0,
     647                            caca_get_canvas_width(cv),
     648                            caca_get_canvas_height(cv),
    650649                            dither, screen);
    651650        break;
     
    653652    case FREE:
    654653        free(screen);
    655         cucul_free_dither(dither);
     654        caca_free_dither(dither);
    656655        break;
    657656    }
     
    688687#define ITER 2
    689688
    690 void langton(enum action action, cucul_canvas_t *cv)
     689void langton(enum action action, caca_canvas_t *cv)
    691690{
    692691    static char gradient[] =
     
    705704    {
    706705    case PREPARE:
    707         width = cucul_get_canvas_width(cv);
    708         height = cucul_get_canvas_height(cv);
     706        width = caca_get_canvas_width(cv);
     707        height = caca_get_canvas_height(cv);
    709708        for(i = 0; i < ANTS; i++)
    710709        {
    711             ax[i] = cucul_rand(0, width);
    712             ay[i] = cucul_rand(0, height);
    713             dir[i] = cucul_rand(0, 4);
     710            ax[i] = caca_rand(0, width);
     711            ay[i] = caca_rand(0, height);
     712            dir[i] = caca_rand(0, 4);
    714713        }
    715714        break;
     
    758757
    759758                if(p & 0x0f)
    760                     cucul_set_color_ansi(cv, CUCUL_WHITE, p >> 4);
     759                    caca_set_color_ansi(cv, CACA_WHITE, p >> 4);
    761760                else
    762                     cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_BLACK);
    763                 cucul_put_char(cv, x, y, gradient[p & 0x0f]);
     761                    caca_set_color_ansi(cv, CACA_BLACK, CACA_BLACK);
     762                caca_put_char(cv, x, y, gradient[p & 0x0f]);
    764763            }
    765764        }
     
    777776#define MAXLEN 30
    778777
    779 void matrix(enum action action, cucul_canvas_t *cv)
     778void matrix(enum action action, caca_canvas_t *cv)
    780779{
    781780    static struct drop
     
    793792        for(i = 0; i < MAXDROPS; i++)
    794793        {
    795             drop[i].x = cucul_rand(0, 1000);
    796             drop[i].y = cucul_rand(0, 1000);
    797             drop[i].speed = 5 + cucul_rand(0, 30);
    798             drop[i].len = MINLEN + cucul_rand(0, (MAXLEN - MINLEN));
     794            drop[i].x = caca_rand(0, 1000);
     795            drop[i].y = caca_rand(0, 1000);
     796            drop[i].speed = 5 + caca_rand(0, 30);
     797            drop[i].len = MINLEN + caca_rand(0, (MAXLEN - MINLEN));
    799798            for(j = 0; j < MAXLEN; j++)
    800                 drop[i].str[j] = cucul_rand('0', 'z');
     799                drop[i].str[j] = caca_rand('0', 'z');
    801800        }
    802801        break;
     
    806805
    807806    case UPDATE:
    808         w = cucul_get_canvas_width(cv);
    809         h = cucul_get_canvas_height(cv);
     807        w = caca_get_canvas_width(cv);
     808        h = caca_get_canvas_height(cv);
    810809
    811810        for(i = 0; i < MAXDROPS && i < (w * h / 32); i++)
     
    815814            {
    816815                drop[i].y -= 1000;
    817                 drop[i].x = cucul_rand(0, 1000);
     816                drop[i].x = caca_rand(0, 1000);
    818817            }
    819818        }
     
    821820
    822821    case RENDER:
    823         w = cucul_get_canvas_width(cv);
    824         h = cucul_get_canvas_height(cv);
    825 
    826         cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_BLACK);
    827         cucul_clear_canvas(cv);
     822        w = caca_get_canvas_width(cv);
     823        h = caca_get_canvas_height(cv);
     824
     825        caca_set_color_ansi(cv, CACA_BLACK, CACA_BLACK);
     826        caca_clear_canvas(cv);
    828827
    829828        for(i = 0; i < MAXDROPS && i < (w * h / 32); i++)
     
    839838
    840839                if(j < 2)
    841                     fg = CUCUL_WHITE;
     840                    fg = CACA_WHITE;
    842841                else if(j < drop[i].len / 4)
    843                     fg = CUCUL_LIGHTGREEN;
     842                    fg = CACA_LIGHTGREEN;
    844843                else if(j < drop[i].len * 4 / 5)
    845                     fg = CUCUL_GREEN;
     844                    fg = CACA_GREEN;
    846845                else
    847                     fg = CUCUL_DARKGRAY;
    848                 cucul_set_color_ansi(cv, fg, CUCUL_BLACK);
    849 
    850                 cucul_put_char(cv, x, y - j,
     846                    fg = CACA_DARKGRAY;
     847                caca_set_color_ansi(cv, fg, CACA_BLACK);
     848
     849                caca_put_char(cv, x, y - j,
    851850                               drop[i].str[(y - j) % drop[i].len]);
    852851            }
     
    872871#include "texture.h"
    873872
    874 void rotozoom(enum action action, cucul_canvas_t *canvas)
     873void rotozoom(enum action action, caca_canvas_t *canvas)
    875874{
    876875    static uint32_t screen[XSIZ * YSIZ];
     
    878877    static int y_tab[TEXTURE_SIZE];
    879878
    880     static cucul_dither_t *dither;
     879    static caca_dither_t *dither;
    881880    static uint32_t *texture;
    882881    uint32_t *p;
     
    904903
    905904    case INIT:
    906         dither = cucul_create_dither(32, XSIZ, YSIZ, XSIZ * 4,
     905        dither = caca_create_dither(32, XSIZ, YSIZ, XSIZ * 4,
    907906                                     0x00FF0000,
    908907                                     0x0000FF00,
     
    942941
    943942    case RENDER:
    944         cucul_dither_bitmap(canvas, 0, 0,
    945                             cucul_get_canvas_width(canvas),
    946                             cucul_get_canvas_height(canvas),
     943        caca_dither_bitmap(canvas, 0, 0,
     944                            caca_get_canvas_width(canvas),
     945                            caca_get_canvas_height(canvas),
    947946                            dither, screen);
    948947        break;
    949948
    950949    case FREE:
    951         cucul_free_dither(dither);
    952         break;
    953     }
    954 }
    955 
     950        caca_free_dither(dither);
     951        break;
     952    }
     953}
     954
  • libcaca/trunk/src/cacadraw.c

    r2299 r2821  
    2121#endif
    2222
    23 #include "cucul.h"
    2423#include "caca.h"
    2524
    2625static int refresh_screen(void);
    2726
    28 static cucul_canvas_t *cv, *image;
     27static caca_canvas_t *cv, *image;
    2928static caca_display_t *dp;
    3029static int x = 0, y = 0;
     
    4140    }
    4241
    43     cv = cucul_create_canvas(0, 0);
     42    cv = caca_create_canvas(0, 0);
    4443    if(!cv)
    4544        return 1;
     
    5655        if(!image)
    5756        {
    58             image = cucul_create_canvas(0, 0);
    59             if(cucul_import_file(image, argv[file], "ansi") < 0)
     57            image = caca_create_canvas(0, 0);
     58            if(caca_import_file(image, argv[file], "ansi") < 0)
    6059            {
    6160                fprintf(stderr, "%s: invalid file `%s'.\n", argv[0], argv[1]);
     
    6362            }
    6463
    65             ih = cucul_get_canvas_height(image);
    66             iw = cucul_get_canvas_width(image);
     64            ih = caca_get_canvas_height(image);
     65            iw = caca_get_canvas_width(image);
    6766            x = y = 0;
    6867
     
    9897                    case 'n':
    9998                        file = file + 1 < argc ? file + 1 : 1;
    100                         cucul_free_canvas(image);
     99                        caca_free_canvas(image);
    101100                        image = NULL;
    102101                        goto stopevents;
    103102                    case 'p':
    104103                        file = file > 1 ? file - 1 : argc - 1;
    105                         cucul_free_canvas(image);
     104                        caca_free_canvas(image);
    106105                        image = NULL;
    107106                        goto stopevents;
     
    118117stopevents:
    119118
    120         w = cucul_get_canvas_width(cv);
    121         h = cucul_get_canvas_height(cv);
     119        w = caca_get_canvas_width(cv);
     120        h = caca_get_canvas_height(cv);
    122121
    123122        if(dx | dy)
     
    135134    /* Clean up */
    136135    caca_free_display(dp);
    137     cucul_free_canvas(image);
    138     cucul_free_canvas(cv);
     136    caca_free_canvas(image);
     137    caca_free_canvas(cv);
    139138
    140139    return 0;
     
    143142static int refresh_screen(void)
    144143{
    145     cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_DEFAULT);
    146     cucul_clear_canvas(cv);
     144    caca_set_color_ansi(cv, CACA_DEFAULT, CACA_DEFAULT);
     145    caca_clear_canvas(cv);
    147146
    148     cucul_blit(cv, - x, - y, image, NULL);
     147    caca_blit(cv, - x, - y, image, NULL);
    149148
    150149    caca_refresh_display(dp);
  • libcaca/trunk/src/cacaplay.c

    r2300 r2821  
    2525#endif
    2626
    27 #include "cucul.h"
    2827#include "caca.h"
    2928
    3029int main(int argc, char **argv)
    3130{
    32     cucul_canvas_t *cv, *app;
     31    caca_canvas_t *cv, *app;
    3332    caca_display_t *dp;
    3433    uint8_t *buf = NULL;
     
    5049    }
    5150
    52     cv = cucul_create_canvas(0, 0);
    53     app = cucul_create_canvas(0, 0);
     51    cv = caca_create_canvas(0, 0);
     52    app = caca_create_canvas(0, 0);
    5453    if(cv == NULL || app == NULL)
    5554    {
     
    9190        }
    9291
    93         bytes = cucul_import_memory(app, buf, total, "caca");
     92        bytes = caca_import_memory(app, buf, total, "caca");
    9493
    9594        if(bytes > 0)
     
    9897            memmove(buf, buf + bytes, total);
    9998
    100             cucul_blit(cv, 0, 0, app, NULL);
     99            caca_blit(cv, 0, 0, app, NULL);
    101100            caca_refresh_display(dp);
    102101        }
     
    117116
    118117    caca_free_display(dp);
    119     cucul_free_canvas(cv);
     118    caca_free_canvas(cv);
    120119
    121120    return 0;
  • libcaca/trunk/src/cacaserver.c

    r2313 r2821  
    4343#endif
    4444
    45 #include "cucul.h"
     45#include "caca.h"
    4646
    4747#define BACKLOG 1337     /* Number of pending connections */
     
    111111    char prefix[sizeof(INIT_PREFIX)];
    112112
    113     cucul_canvas_t *canvas;
     113    caca_canvas_t *canvas;
    114114    void *buffer;
    115115    size_t buflen;
     
    190190    }
    191191
    192     server->canvas = cucul_create_canvas(0, 0);
     192    server->canvas = caca_create_canvas(0, 0);
    193193    server->buffer = NULL;
    194194
     
    214214        }
    215215
    216         while(cucul_import_memory(server->canvas, server->input,
     216        while(caca_import_memory(server->canvas, server->input,
    217217                                  server->read, "caca") < 0)
    218218        {
     
    225225            ssize_t needed, wanted;
    226226
    227             needed = cucul_import_memory(server->canvas, server->input,
     227            needed = caca_import_memory(server->canvas, server->input,
    228228                                         server->read, "caca");
    229229            if(needed < 0)
     
    253253        /* Get ANSI representation of the image and skip the end-of buffer
    254254         * linefeed ("\r\n", 2 byte) */
    255         server->buffer = cucul_export_memory(server->canvas, "utf8cr",
     255        server->buffer = caca_export_memory(server->canvas, "utf8cr",
    256256                                             &server->buflen);
    257257        server->buflen -= 2;
     
    285285        free(server->buffer);
    286286
    287     cucul_free_canvas(server->canvas);
     287    caca_free_canvas(server->canvas);
    288288
    289289    /* Restore SIGPIPE handler */
  • libcaca/trunk/src/cacaview.c

    r2299 r2821  
    2525#endif
    2626
    27 #include "cucul.h"
    2827#include "caca.h"
    2928
     
    4544#define PAD_STEP 0.15
    4645
    47 /* libcucul/libcaca contexts */
    48 cucul_canvas_t *cv; caca_display_t *dp;
     46/* libcaca/libcaca contexts */
     47caca_canvas_t *cv; caca_display_t *dp;
    4948
    5049/* Local functions */
     
    6564int main(int argc, char **argv)
    6665{
    67     char const * const * algos = cucul_get_dither_algorithm_list(NULL);
     66    char const * const * algos = caca_get_dither_algorithm_list(NULL);
    6867    int dither_algorithm = 0;
    6968
     
    7574    int i;
    7675
    77     /* Initialise libcucul */
    78     cv = cucul_create_canvas(0, 0);
     76    /* Initialise libcaca */
     77    cv = caca_create_canvas(0, 0);
    7978    if(!cv)
    80     {
    81         fprintf(stderr, "%s: unable to initialise libcucul\n", argv[0]);
    82         return 1;
    83     }
    84 
    85     dp = caca_create_display(cv);
    86     if(!dp)
    8779    {
    8880        fprintf(stderr, "%s: unable to initialise libcaca\n", argv[0]);
     
    9082    }
    9183
     84    dp = caca_create_display(cv);
     85    if(!dp)
     86    {
     87        fprintf(stderr, "%s: unable to initialise libcaca\n", argv[0]);
     88        return 1;
     89    }
     90
    9291    /* Set the window title */
    9392    caca_set_display_title(dp, "cacaview");
    9493
    95     ww = cucul_get_canvas_width(cv);
    96     wh = cucul_get_canvas_height(cv);
     94    ww = caca_get_canvas_width(cv);
     95    wh = caca_get_canvas_height(cv);
    9796
    9897    /* Fill the zoom table */
     
    181180#if 0 /* FIXME */
    182181            case 'b':
    183                 i = 1 + cucul_get_feature(cv, CUCUL_BACKGROUND);
    184                 if(i > CUCUL_BACKGROUND_MAX) i = CUCUL_BACKGROUND_MIN;
    185                 cucul_set_feature(cv, i);
     182                i = 1 + caca_get_feature(cv, CACA_BACKGROUND);
     183                if(i > CACA_BACKGROUND_MAX) i = CACA_BACKGROUND_MIN;
     184                caca_set_feature(cv, i);
    186185                new_status = STATUS_BACKGROUND;
    187186                update = 1;
    188187                break;
    189188            case 'B':
    190                 i = -1 + cucul_get_feature(cv, CUCUL_BACKGROUND);
    191                 if(i < CUCUL_BACKGROUND_MIN) i = CUCUL_BACKGROUND_MAX;
    192                 cucul_set_feature(cv, i);
     189                i = -1 + caca_get_feature(cv, CACA_BACKGROUND);
     190                if(i < CACA_BACKGROUND_MIN) i = CACA_BACKGROUND_MAX;
     191                caca_set_feature(cv, i);
    193192                new_status = STATUS_BACKGROUND;
    194193                update = 1;
    195194                break;
    196195            case 'a':
    197                 i = 1 + cucul_get_feature(cv, CUCUL_ANTIALIASING);
    198                 if(i > CUCUL_ANTIALIASING_MAX) i = CUCUL_ANTIALIASING_MIN;
    199                 cucul_set_feature(cv, i);
     196                i = 1 + caca_get_feature(cv, CACA_ANTIALIASING);
     197                if(i > CACA_ANTIALIASING_MAX) i = CACA_ANTIALIASING_MIN;
     198                caca_set_feature(cv, i);
    200199                new_status = STATUS_ANTIALIASING;
    201200                update = 1;
    202201                break;
    203202            case 'A':
    204                 i = -1 + cucul_get_feature(cv, CUCUL_ANTIALIASING);
    205                 if(i < CUCUL_ANTIALIASING_MIN) i = CUCUL_ANTIALIASING_MAX;
    206                 cucul_set_feature(cv, i);
     203                i = -1 + caca_get_feature(cv, CACA_ANTIALIASING);
     204                if(i < CACA_ANTIALIASING_MIN) i = CACA_ANTIALIASING_MAX;
     205                caca_set_feature(cv, i);
    207206                new_status = STATUS_ANTIALIASING;
    208207                update = 1;
     
    213212                if(algos[dither_algorithm * 2] == NULL)
    214213                    dither_algorithm = 0;
    215                 cucul_set_dither_algorithm(im->dither,
     214                caca_set_dither_algorithm(im->dither,
    216215                                           algos[dither_algorithm * 2]);
    217216                new_status = STATUS_DITHERING;
     
    223222                    while(algos[dither_algorithm * 2 + 2] != NULL)
    224223                        dither_algorithm++;
    225                 cucul_set_dither_algorithm(im->dither,
     224                caca_set_dither_algorithm(im->dither,
    226225                                           algos[dither_algorithm * 2]);
    227226                new_status = STATUS_DITHERING;
     
    320319            sprintf(buffer, " Loading `%s'... ", list[current]);
    321320            buffer[ww] = '\0';
    322             cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    323             cucul_put_str(cv, (ww - strlen(buffer)) / 2, wh / 2, buffer);
     321            caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     322            caca_put_str(cv, (ww - strlen(buffer)) / 2, wh / 2, buffer);
    324323            caca_refresh_display(dp);
    325             ww = cucul_get_canvas_width(cv);
    326             wh = cucul_get_canvas_height(cv);
     324            ww = caca_get_canvas_width(cv);
     325            wh = caca_get_canvas_height(cv);
    327326
    328327            if(im)
     
    340339        }
    341340
    342         cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);
    343         cucul_clear_canvas(cv);
     341        caca_set_color_ansi(cv, CACA_WHITE, CACA_BLACK);
     342        caca_clear_canvas(cv);
    344343
    345344        if(!items)
    346345        {
    347             cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    348             cucul_printf(cv, ww / 2 - 5, wh / 2, " No image. ");
     346            caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     347            caca_printf(cv, ww / 2 - 5, wh / 2, " No image. ");
    349348        }
    350349        else if(!im)
     
    365364            sprintf(buffer, ERROR_STRING, list[current]);
    366365            buffer[ww] = '\0';
    367             cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    368             cucul_put_str(cv, (ww - strlen(buffer)) / 2, wh / 2, buffer);
     366            caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     367            caca_put_str(cv, (ww - strlen(buffer)) / 2, wh / 2, buffer);
    369368            free(buffer);
    370369        }
     
    384383                          ww * xfactor, height * yfactor);
    385384
    386             cucul_dither_bitmap(cv, ww * (1.0 - xfactor) * xdelta,
     385            caca_dither_bitmap(cv, ww * (1.0 - xfactor) * xdelta,
    387386                            y + height * (1.0 - yfactor) * ydelta,
    388387                            ww * xfactor + 1, height * yfactor + 1,
     
    394393            print_status();
    395394
    396             cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
     395            caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
    397396            switch(status)
    398397            {
    399398                case STATUS_DITHERING:
    400                     cucul_printf(cv, 0, wh - 1, "Dithering: %s",
    401                                  cucul_get_dither_algorithm(im->dither));
     399                    caca_printf(cv, 0, wh - 1, "Dithering: %s",
     400                                 caca_get_dither_algorithm(im->dither));
    402401                    break;
    403402#if 0 /* FIXME */
    404403                case STATUS_ANTIALIASING:
    405                     cucul_printf(cv, 0, wh - 1, "Antialiasing: %s",
    406                   cucul_get_feature_name(cucul_get_feature(cv, CUCUL_ANTIALIASING)));
     404                    caca_printf(cv, 0, wh - 1, "Antialiasing: %s",
     405                  caca_get_feature_name(caca_get_feature(cv, CACA_ANTIALIASING)));
    407406                    break;
    408407                case STATUS_BACKGROUND:
    409                     cucul_printf(cv, 0, wh - 1, "Background: %s",
    410                   cucul_get_feature_name(cucul_get_feature(cv, CUCUL_BACKGROUND)));
     408                    caca_printf(cv, 0, wh - 1, "Background: %s",
     409                  caca_get_feature_name(caca_get_feature(cv, CACA_BACKGROUND)));
    411410                    break;
    412411#endif
     
    427426        unload_image(im);
    428427    caca_free_display(dp);
    429     cucul_free_canvas(cv);
     428    caca_free_canvas(cv);
    430429
    431430    return 0;
     
    434433static void print_status(void)
    435434{
    436     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
    437     cucul_draw_line(cv, 0, 0, ww - 1, 0, ' ');
    438     cucul_draw_line(cv, 0, wh - 2, ww - 1, wh - 2, '-');
    439     cucul_put_str(cv, 0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  gG:Gamma  "
     435    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
     436    caca_draw_line(cv, 0, 0, ww - 1, 0, ' ');
     437    caca_draw_line(cv, 0, wh - 2, ww - 1, wh - 2, '-');
     438    caca_put_str(cv, 0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  gG:Gamma  "
    440439                            "hjkl:Move  d:Dither  a:Antialias");
    441     cucul_put_str(cv, ww - strlen("?:Help"), 0, "?:Help");
    442     cucul_printf(cv, 3, wh - 2, "cacaview %s", VERSION);
    443     cucul_printf(cv, ww - 30, wh - 2, "(gamma: %#.3g)", GAMMA(g));
    444     cucul_printf(cv, ww - 14, wh - 2, "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
    445 
    446     cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    447     cucul_draw_line(cv, 0, wh - 1, ww - 1, wh - 1, ' ');
     440    caca_put_str(cv, ww - strlen("?:Help"), 0, "?:Help");
     441    caca_printf(cv, 3, wh - 2, "cacaview %s", VERSION);
     442    caca_printf(cv, ww - 30, wh - 2, "(gamma: %#.3g)", GAMMA(g));
     443    caca_printf(cv, ww - 14, wh - 2, "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
     444
     445    caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
     446    caca_draw_line(cv, 0, wh - 1, ww - 1, wh - 1, ' ');
    448447}
    449448
     
    472471    int i;
    473472
    474     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLUE);
     473    caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
    475474
    476475    for(i = 0; help[i]; i++)
    477         cucul_put_str(cv, x, y + i, help[i]);
     476        caca_put_str(cv, x, y + i, help[i]);
    478477}
    479478
     
    490489    if(zoom < -ZOOM_MAX) zoom = -ZOOM_MAX;
    491490
    492     ww = cucul_get_canvas_width(cv);
     491    ww = caca_get_canvas_width(cv);
    493492    height = fullscreen ? wh : wh - 3;
    494493
    495494    xfactor = (zoom < 0) ? 1.0 / zoomtab[-zoom] : zoomtab[zoom];
    496495    yfactor = xfactor * ww / height * im->h / im->w
    497                * cucul_get_canvas_height(cv) / cucul_get_canvas_width(cv)
     496               * caca_get_canvas_height(cv) / caca_get_canvas_width(cv)
    498497               * caca_get_display_width(dp) / caca_get_display_height(dp);
    499498
     
    516515    if(g < -GAMMA_MAX) g = -GAMMA_MAX;
    517516
    518     cucul_set_dither_gamma(im->dither,
     517    caca_set_dither_gamma(im->dither,
    519518                           (g < 0) ? 1.0 / gammatab[-g] : gammatab[g]);
    520519}
     
    524523    int xn, yn;
    525524
    526     if(x + w > (int)cucul_get_canvas_width(cv))
    527         w = cucul_get_canvas_width(cv) - x;
    528     if(y + h > (int)cucul_get_canvas_height(cv))
    529         h = cucul_get_canvas_height(cv) - y;
     525    if(x + w > (int)caca_get_canvas_width(cv))
     526        w = caca_get_canvas_width(cv) - x;
     527    if(y + h > (int)caca_get_canvas_height(cv))
     528        h = caca_get_canvas_height(cv) - y;
    530529
    531530    for(yn = y > 0 ? y : 0; yn < y + h; yn++)
     
    533532    {
    534533        if((((xn - x) / 5) ^ ((yn - y) / 3)) & 1)
    535             cucul_set_color_ansi(cv, CUCUL_LIGHTGRAY, CUCUL_DARKGRAY);
     534            caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_DARKGRAY);
    536535        else
    537             cucul_set_color_ansi(cv, CUCUL_DARKGRAY, CUCUL_LIGHTGRAY);
    538         cucul_put_char(cv, xn, yn, ' ');
     536            caca_set_color_ansi(cv, CACA_DARKGRAY, CACA_LIGHTGRAY);
     537        caca_put_char(cv, xn, yn, ' ');
    539538    }
    540539}
  • libcaca/trunk/src/common-image.c

    r2436 r2821  
    2424#endif
    2525
    26 #include "cucul.h"
     26#include "caca.h"
    2727
    2828#include "common-image.h"
    2929
    3030#if !defined(USE_IMLIB2)
    31 static unsigned int u32fread(cucul_file_t *);
    32 static unsigned int u16fread(cucul_file_t *);
    33 static unsigned int u8fread(cucul_file_t *);
     31static unsigned int u32fread(caca_file_t *);
     32static unsigned int u16fread(caca_file_t *);
     33static unsigned int u8fread(caca_file_t *);
    3434#endif
    3535
     
    6262    depth = 4;
    6363
    64     /* Create the libcucul dither */
    65     im->dither = cucul_create_dither(bpp, im->w, im->h, depth * im->w,
     64    /* Create the libcaca dither */
     65    im->dither = caca_create_dither(bpp, im->w, im->h, depth * im->w,
    6666                                     rmask, gmask, bmask, amask);
    6767    if(!im->dither)
     
    7878    unsigned int red[256], green[256], blue[256], alpha[256];
    7979    unsigned int i, colors, offset, tmp, planes;
    80     cucul_file_t *f;
    81 
    82     f = cucul_file_open(name, "rb");
     80    caca_file_t *f;
     81
     82    f = caca_file_open(name, "rb");
    8383    if(!f)
    8484    {
     
    8989    if(u16fread(f) != 0x4d42)
    9090    {
    91         cucul_file_close(f);
     91        caca_file_close(f);
    9292        free(im);
    9393        return NULL;
     
    111111        if(tmp != 0)
    112112        {
    113             cucul_file_close(f);
     113            caca_file_close(f);
    114114            free(im);
    115115            return NULL;
     
    150150    else
    151151    {
    152         cucul_file_close(f);
     152        caca_file_close(f);
    153153        free(im);
    154154        return NULL;
     
    164164    if(!im->w || im->w > 0x10000 || !im->h || im->h > 0x10000 || planes != 1)
    165165    {
    166         cucul_file_close(f);
     166        caca_file_close(f);
    167167        free(im);
    168168        return NULL;
     
    173173    if(!im->pixels)
    174174    {
    175         cucul_file_close(f);
     175        caca_file_close(f);
    176176        free(im);
    177177        return NULL;
     
    209209            default:
    210210                /* Works for 8bpp, but also for 16, 24 etc. */
    211                 cucul_file_read(f, im->pixels + im->w * i * depth,
     211                caca_file_read(f, im->pixels + im->w * i * depth,
    212212                                im->w * depth);
    213213                /* Pad reads to 4 bytes */
     
    241241    }
    242242
    243     cucul_file_close(f);
    244 
    245     /* Create the libcucul dither */
    246     im->dither = cucul_create_dither(bpp, im->w, im->h, depth * im->w,
     243    caca_file_close(f);
     244
     245    /* Create the libcaca dither */
     246    im->dither = caca_create_dither(bpp, im->w, im->h, depth * im->w,
    247247                                     rmask, gmask, bmask, amask);
    248248    if(!im->dither)
     
    254254
    255255    if(bpp == 8)
    256         cucul_set_dither_palette(im->dither, red, green, blue, alpha);
     256        caca_set_dither_palette(im->dither, red, green, blue, alpha);
    257257#endif
    258258
     
    268268    free(im->pixels);
    269269#endif
    270     cucul_free_dither(im->dither);
     270    caca_free_dither(im->dither);
    271271}
    272272
    273273#if !defined(USE_IMLIB2)
    274 static unsigned int u32fread(cucul_file_t * f)
     274static unsigned int u32fread(caca_file_t * f)
    275275{
    276276    uint8_t buffer[4];
    277     cucul_file_read(f, buffer, 4);
     277    caca_file_read(f, buffer, 4);
    278278    return ((unsigned int)buffer[3] << 24) | ((unsigned int)buffer[2] << 16)
    279279             | ((unsigned int)buffer[1] << 8) | ((unsigned int)buffer[0]);
    280280}
    281281
    282 static unsigned int u16fread(cucul_file_t * f)
     282static unsigned int u16fread(caca_file_t * f)
    283283{
    284284    uint8_t buffer[2];
    285     cucul_file_read(f, buffer, 2);
     285    caca_file_read(f, buffer, 2);
    286286    return ((unsigned int)buffer[1] << 8) | ((unsigned int)buffer[0]);
    287287}
    288288
    289 static unsigned int u8fread(cucul_file_t * f)
     289static unsigned int u8fread(caca_file_t * f)
    290290{
    291291    uint8_t buffer;
    292     cucul_file_read(f, &buffer, 1);
     292    caca_file_read(f, &buffer, 1);
    293293    return (unsigned int)buffer;
    294294}
  • libcaca/trunk/src/common-image.h

    r1462 r2821  
    1717    char *pixels;
    1818    unsigned int w, h;
    19     struct cucul_dither *dither;
     19    struct caca_dither *dither;
    2020    void *priv;
    2121};
  • libcaca/trunk/src/img2txt.c

    r2313 r2821  
    3434#endif
    3535
    36 #include "cucul.h"
     36#include "caca.h"
    3737
    3838#include "common-image.h"
     
    5858    fprintf(stderr, "  -g, --gamma=GAMMA\t\tGamma of resulting image\n");
    5959    fprintf(stderr, "  -d, --dither=DITHER\t\tDithering algorithm to use :\n");
    60     list = cucul_get_dither_algorithm_list(NULL);
     60    list = caca_get_dither_algorithm_list(NULL);
    6161    while(*list)
    6262    {
     
    6666
    6767    fprintf(stderr, "  -f, --format=FORMAT\t\tFormat of the resulting image :\n");
    68     list = cucul_get_export_list();
     68    list = caca_get_export_list();
    6969    while(*list)
    7070    {
     
    8989    "        http://libcaca.zoy.org/ in the libcaca package.\n"
    9090    "\n",
    91     cucul_get_version(), __DATE__);
     91    caca_get_version(), __DATE__);
    9292}
    9393int main(int argc, char **argv)
    9494{
    95     /* libcucul context */
    96     cucul_canvas_t *cv;
     95    /* libcaca context */
     96    caca_canvas_t *cv;
    9797    void *export;
    9898    size_t len;
     
    175175
    176176
    177     cv = cucul_create_canvas(0, 0);
     177    cv = caca_create_canvas(0, 0);
    178178    if(!cv)
    179179    {
    180         fprintf(stderr, "%s: unable to initialise libcucul\n", argv[0]);
     180        fprintf(stderr, "%s: unable to initialise libcaca\n", argv[0]);
    181181        return 1;
    182182    }
     
    186186    {
    187187        fprintf(stderr, "%s: unable to load %s\n", argv[0], argv[argc-1]);
    188         cucul_free_canvas(cv);
     188        caca_free_canvas(cv);
    189189        return 1;
    190190    }
     
    206206
    207207
    208     cucul_set_canvas_size(cv, cols, lines);
    209     cucul_set_color_ansi(cv, CUCUL_DEFAULT, CUCUL_TRANSPARENT);
    210     cucul_clear_canvas(cv);
    211     if(cucul_set_dither_algorithm(i->dither, dither?dither:"fstein"))
     208    caca_set_canvas_size(cv, cols, lines);
     209    caca_set_color_ansi(cv, CACA_DEFAULT, CACA_TRANSPARENT);
     210    caca_clear_canvas(cv);
     211    if(caca_set_dither_algorithm(i->dither, dither?dither:"fstein"))
    212212    {
    213213        fprintf(stderr, "%s: Can't dither image with algorithm '%s'\n", argv[0], dither);
    214214        unload_image(i);
    215         cucul_free_canvas(cv);
     215        caca_free_canvas(cv);
    216216        return -1;
    217217    }
    218218
    219     if(brightness!=-1) cucul_set_dither_brightness (i->dither, brightness);
    220     if(contrast!=-1) cucul_set_dither_contrast (i->dither, contrast);
    221     if(gamma!=-1) cucul_set_dither_gamma (i->dither, gamma);
    222 
    223     cucul_dither_bitmap(cv, 0, 0, cols, lines, i->dither, i->pixels);
     219    if(brightness!=-1) caca_set_dither_brightness (i->dither, brightness);
     220    if(contrast!=-1) caca_set_dither_contrast (i->dither, contrast);
     221    if(gamma!=-1) caca_set_dither_gamma (i->dither, gamma);
     222
     223    caca_dither_bitmap(cv, 0, 0, cols, lines, i->dither, i->pixels);
    224224
    225225    unload_image(i);
    226226
    227     export = cucul_export_memory(cv, format?format:"ansi", &len);
     227    export = caca_export_memory(cv, format?format:"ansi", &len);
    228228    if(!export)
    229229    {
     
    236236    }
    237237
    238     cucul_free_canvas(cv);
     238    caca_free_canvas(cv);
    239239
    240240    return 0;
  • libcaca/trunk/src/mygetopt.c

    r2543 r2821  
    2222#include <string.h>
    2323
    24 #include "cucul_types.h"
     24#include "caca_types.h"
    2525
    2626#include "mygetopt.h"
Note: See TracChangeset for help on using the changeset viewer.