Changeset 1308


Ignore:
Timestamp:
Nov 8, 2006, 6:26:57 PM (13 years ago)
Author:
Sam Hocevar
Message:
  • Convert all programs and tests to the new import/export API.
Location:
libcaca/trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/src/cacadraw.c

    r1267 r1308  
    5656        if(!image)
    5757        {
    58             cucul_buffer_t *b = cucul_load_file(argv[file]);
    59             if(!b)
    60             {
    61                 fprintf(stderr, "%s: could not open `%s'.\n", argv[0], argv[1]);
    62                 return 1;
    63             }
    64 
    65             image = cucul_import_canvas(b, "ansi");
    66             if(!image)
     58            image = cucul_create_canvas(0, 0);
     59            if(cucul_import_file(image, argv[file], "ansi") < 0)
    6760            {
    6861                fprintf(stderr, "%s: invalid file `%s'.\n", argv[0], argv[1]);
    6962                return 1;
    7063            }
    71 
    72             cucul_free_buffer(b);
    7364
    7465            ih = cucul_get_canvas_height(image);
  • libcaca/trunk/src/cacaplay.c

    r1048 r1308  
    2626{
    2727    caca_event_t ev;
    28     cucul_buffer_t *b;
    2928    cucul_canvas_t *cv;
    3029    caca_display_t *dp;
     
    3635    }
    3736
    38     b = cucul_load_file(argv[1]);
    39     if(!b)
     37    cv = cucul_create_canvas(0, 0);
     38    if(cucul_import_file(cv, argv[1], "caca") < 0)
    4039    {
    41         fprintf(stderr, "%s: could not open %s.\n", argv[0], argv[1]);
     40        fprintf(stderr, "%s: could not import file %s.\n", argv[0], argv[1]);
    4241        return 1;
    4342    }
    44 
    45     cv = cucul_import_canvas(b, "caca");
    46     if(!cv)
    47     {
    48         fprintf(stderr, "%s: invalid caca file %s.\n", argv[0], argv[1]);
    49         cucul_free_buffer(b);
    50         return 1;
    51     }
    52 
    53     cucul_free_buffer(b);
    5443
    5544    dp = caca_create_display(cv);
  • libcaca/trunk/src/cacaserver.c

    r1300 r1308  
    106106
    107107    cucul_canvas_t *canvas;
    108     cucul_buffer_t *buffer;
     108    void *buffer;
    109109    unsigned long int buflen;
    110     void *bufdata;
    111110
    112111    int client_count;
     
    185184    }
    186185
    187     server->canvas = NULL;
     186    server->canvas = cucul_create_canvas(0, 0);
    188187    server->buffer = NULL;
    189188
     
    197196    for(;;)
    198197    {
    199         cucul_buffer_t *b;
    200198        uint8_t *buf = server->input;
    201199        uint32_t control_size, data_size;
     
    225223        read(0, buf + 12, size - 12);
    226224
    227         /* Free the previous canvas, if any */
    228         if(server->canvas)
    229             cucul_free_canvas(server->canvas);
    230 
    231         b = cucul_load_memory(buf, size);
    232         server->canvas = cucul_import_canvas(b, "caca");
    233         cucul_free_buffer(b);
    234 
    235         if(!server->canvas)
     225        if(cucul_import_memory(server->canvas, buf, size, "caca") < 0)
    236226            continue; /* Load error */
    237227
     
    239229        if(server->buffer)
    240230        {
    241             cucul_free_buffer(server->buffer);
     231            free(server->buffer);
    242232            server->buffer = NULL;
    243233        }
     
    245235        /* Get ANSI representation of the image and skip the end-of buffer
    246236         * linefeed ("\r\n", 2 byte) */
    247         server->buffer = cucul_export_canvas(server->canvas, "utf8cr");
    248         server->bufdata = cucul_get_buffer_data(server->buffer);
    249         server->buflen = cucul_get_buffer_size(server->buffer);
     237        server->buffer = cucul_export_memory(server->canvas, "utf8cr",
     238                                             &server->buflen);
    250239        server->buflen -= 2;
    251240
     
    276265
    277266    if(server->buffer)
    278         cucul_free_buffer(server->buffer);
     267        free(server->buffer);
     268
     269    cucul_free_canvas(server->canvas);
    279270
    280271    /* Restore SIGPIPE handler */
     
    453444            memcpy(c->outbuf + c->stop, ANSI_PREFIX, strlen(ANSI_PREFIX));
    454445            c->stop += strlen(ANSI_PREFIX);
    455             memcpy(c->outbuf + c->stop, server->bufdata, server->buflen);
     446            memcpy(c->outbuf + c->stop, server->buffer, server->buflen);
    456447            c->stop += server->buflen;
    457448
     
    488479        memcpy(c->outbuf, ANSI_PREFIX, strlen(ANSI_PREFIX) - ret);
    489480        c->stop = strlen(ANSI_PREFIX) - ret;
    490         memcpy(c->outbuf + c->stop, server->bufdata, server->buflen);
     481        memcpy(c->outbuf + c->stop, server->buffer, server->buflen);
    491482        c->stop += server->buflen;
    492483
     
    495486
    496487    /* Send actual data */
    497     ret = nonblock_write(c->fd, server->bufdata, server->buflen);
     488    ret = nonblock_write(c->fd, server->buffer, server->buflen);
    498489    if(ret == -1)
    499490    {
     
    518509        }
    519510
    520         memcpy(c->outbuf, server->bufdata, server->buflen - ret);
     511        memcpy(c->outbuf, server->buffer, server->buflen - ret);
    521512        c->stop = server->buflen - ret;
    522513
  • libcaca/trunk/src/img2irc.c

    r1267 r1308  
    2828    /* libcucul context */
    2929    cucul_canvas_t *cv;
    30     cucul_buffer_t *export;
     30    void *export;
     31    unsigned long int len;
    3132    struct image *i;
    3233    int cols = 56, lines;
     
    6364    unload_image(i);
    6465
    65     export = cucul_export_canvas(cv, "irc");
    66     fwrite(cucul_get_buffer_data(export),
    67            cucul_get_buffer_size(export), 1, stdout);
    68     cucul_free_buffer(export);
     66    export = cucul_export_memory(cv, "irc", &len);
     67    fwrite(export, len, 1, stdout);
     68    free(export);
    6969
    7070    cucul_free_canvas(cv);
  • libcaca/trunk/test/export.c

    r1267 r1308  
    3535    cucul_canvas_t *cv;
    3636    cucul_dither_t *dither;
    37     cucul_buffer_t *buffer;
     37    void *buffer;
    3838    char *file, *format;
    3939    char const * const * exports, * const * p;
     40    unsigned long int len;
    4041    int x, y;
    4142
     
    7879    if(file)
    7980    {
    80         cucul_buffer_t *tmp;
    81         tmp = cucul_load_file(file);
    82         if(!tmp)
    83         {
    84             fprintf(stderr, "%s: could not load `%s'\n", argv[0], file);
    85             exit(-1);
    86         }
    87         cv = cucul_import_canvas(tmp, "");
    88         if(!cv)
     81        cv = cucul_create_canvas(0, 0);
     82        if(cucul_import_file(cv, file, "") < 0)
    8983        {
    9084            fprintf(stderr, "%s: `%s' has unknown format\n", argv[0], file);
    9185            exit(-1);
    9286        }
    93         cucul_free_buffer(tmp);
    9487    }
    9588    else
     
    147140    }
    148141
    149     buffer = cucul_export_canvas(cv, format);
    150     fwrite(cucul_get_buffer_data(buffer),
    151            cucul_get_buffer_size(buffer), 1, stdout);
    152     cucul_free_buffer(buffer);
     142    buffer = cucul_export_memory(cv, format, &len);
     143    fwrite(buffer, len, 1, stdout);
     144    free(buffer);
    153145
    154146    cucul_free_canvas(cv);
  • libcaca/trunk/test/font2tga.c

    r1294 r1308  
    3333    char const * const * fonts;
    3434    cucul_canvas_t *cv;
    35     cucul_buffer_t *buffer;
     35    void *buffer;
     36    unsigned long int len;
    3637    unsigned int i, j, x, y, glyphs;
    3738
     
    6667    cucul_free_font(f);
    6768
    68     buffer = cucul_export_canvas(cv, "tga");
    69     fwrite(cucul_get_buffer_data(buffer),
    70            cucul_get_buffer_size(buffer), 1, stdout);
    71     cucul_free_buffer(buffer);
     69    buffer = cucul_export_memory(cv, "tga", &len);
     70    fwrite(buffer, len, 1, stdout);
     71    free(buffer);
    7272
    7373    /* Free everything */
  • libcaca/trunk/test/import.c

    r1153 r1308  
    3131{
    3232    cucul_canvas_t *cv;
    33     cucul_buffer_t *b;
    3433    caca_display_t *dp;
    3534
     
    4140    }
    4241
    43     b = cucul_load_file(argv[1]);
    44     if(!b)
     42    cv = cucul_create_canvas(0, 0);
     43    if(cucul_import_file(cv, argv[1], argc >= 3 ? argv[2] : "") < 0)
    4544    {
    4645        fprintf(stderr, "%s: could not open `%s'.\n", argv[0], argv[1]);
     46        cucul_free_canvas(cv);
    4747        return 1;
    4848    }
    49 
    50     cv = cucul_import_canvas(b, argc >= 3 ? argv[2] : "");
    51     if(!cv)
    52     {
    53         fprintf(stderr, "%s: could not import `%s'.\n", argv[0], argv[1]);
    54         return 1;
    55     }
    56 
    57     cucul_free_buffer(b);
    5849
    5950    dp = caca_create_display(cv);
  • libcaca/trunk/test/text.c

    r1048 r1308  
    2020#   include <stdio.h>
    2121#   include <string.h>
     22#   include <stdlib.h>
    2223#endif
    2324#include "cucul.h"
     
    3435{
    3536    cucul_canvas_t *cv;
    36     cucul_buffer_t *buffer;
     37    void *buffer;
     38    unsigned long int len;
    3739
    38     buffer = cucul_load_memory(STRING, strlen(STRING));
    39     cv = cucul_import_canvas(buffer, "text");
    40     cucul_free_buffer(buffer);
     40    cv = cucul_create_canvas(0, 0);
    4141
    42     buffer = cucul_export_canvas(cv, "utf8");
    43     fwrite(cucul_get_buffer_data(buffer),
    44            cucul_get_buffer_size(buffer), 1, stdout);
    45     cucul_free_buffer(buffer);
     42    cucul_import_memory(cv, STRING, strlen(STRING), "text");
     43
     44    buffer = cucul_export_memory(cv, "utf8", &len);
     45    fwrite(buffer, len, 1, stdout);
     46    free(buffer);
    4647
    4748    cucul_rotate(cv);
    4849
    49     buffer = cucul_export_canvas(cv, "utf8");
    50     fwrite(cucul_get_buffer_data(buffer),
    51            cucul_get_buffer_size(buffer), 1, stdout);
    52     cucul_free_buffer(buffer);
     50    buffer = cucul_export_memory(cv, "utf8", &len);
     51    fwrite(buffer, len, 1, stdout);
     52    free(buffer);
    5353
    5454    cucul_free_canvas(cv);
Note: See TracChangeset for help on using the changeset viewer.