Changeset 1338 for libcaca


Ignore:
Timestamp:
Nov 11, 2006, 1:57:03 PM (16 years ago)
Author:
Sam Hocevar
Message:
  • Prepare the way for per-frame width/height information.
Location:
libcaca/trunk/cucul
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/cucul/canvas.c

    r1313 r1338  
    391391        cucul_blit(new, -x, -y, cv, NULL);
    392392
    393         free(cv->allchars[f]);
    394         free(cv->allattrs[f]);
    395     }
    396     free(cv->allchars);
    397     free(cv->allattrs);
     393        free(cv->frames[f].chars);
     394        free(cv->frames[f].attrs);
     395    }
     396    free(cv->frames);
    398397
    399398    memcpy(cv, new, sizeof(cucul_canvas_t));
  • libcaca/trunk/cucul/cucul.c

    r1337 r1338  
    6969    cv->frame = 0;
    7070    cv->framecount = 1;
    71     cv->allchars = malloc(sizeof(uint32_t *));
    72     if(!cv->allchars)
     71    cv->frames = malloc(sizeof(struct cucul_frame));
     72    if(!cv->frames)
    7373    {
    7474        free(cv);
    7575        goto nomem;
    7676    }
    77     cv->allattrs = malloc(sizeof(uint32_t *));
    78     if(!cv->allattrs)
    79     {
    80         free(cv->allchars);
    81         free(cv);
    82         goto nomem;
    83     }
    84     cv->allchars[0] = NULL;
    85     cv->allattrs[0] = NULL;
     77
     78    cv->frames[0].width = cv->frames[0].height = 0;
     79    cv->frames[0].chars = NULL;
     80    cv->frames[0].attrs = NULL;
     81    cv->frames[0].curattr = cv->curattr;
    8682
    8783    if(_cucul_set_canvas_size(cv, width, height) < 0)
     
    9086        int saved_errno = errno;
    9187#endif
    92         free(cv->allattrs);
    93         free(cv->allchars);
     88        free(cv->frames);
    9489        free(cv);
    9590#if defined(HAVE_ERRNO_H)
     
    201196    for(f = 0; f < cv->framecount; f++)
    202197    {
    203         free(cv->allchars[f]);
    204         free(cv->allattrs[f]);
    205     }
    206 
    207     free(cv->allchars);
    208     free(cv->allattrs);
     198        free(cv->frames[f].chars);
     199        free(cv->frames[f].attrs);
     200    }
     201
     202    free(cv->frames);
    209203    free(cv);
    210204
     
    258252        for(f = 0; f < cv->framecount; f++)
    259253        {
    260             cv->allchars[f] = realloc(cv->allchars[f],
    261                                       new_size * sizeof(uint32_t));
    262             cv->allattrs[f] = realloc(cv->allattrs[f],
    263                                       new_size * sizeof(uint32_t));
    264             if(new_size && (!cv->allchars[f] || !cv->allattrs[f]))
     254            cv->frames[f].chars = realloc(cv->frames[f].chars,
     255                                          new_size * sizeof(uint32_t));
     256            cv->frames[f].attrs = realloc(cv->frames[f].attrs,
     257                                          new_size * sizeof(uint32_t));
     258            if(new_size && (!cv->frames[f].chars || !cv->frames[f].attrs))
    265259            {
    266260#if defined(HAVE_ERRNO_H)
     
    285279        for(f = 0; f < cv->framecount; f++)
    286280        {
    287             uint32_t *chars = cv->allchars[f];
    288             uint32_t *attrs = cv->allattrs[f];
     281            uint32_t *chars = cv->frames[f].chars;
     282            uint32_t *attrs = cv->frames[f].attrs;
    289283
    290284            for(y = height < old_height ? height : old_height; y--; )
    291285            {
    292                 uint32_t attr = cv->curattr;
     286                uint32_t attr = cv->frames[f].curattr;
    293287
    294288                for(x = old_width; x--; )
     
    315309        for(f = 0; f < cv->framecount; f++)
    316310        {
    317             uint32_t *chars = cv->allchars[f];
    318             uint32_t *attrs = cv->allattrs[f];
     311            uint32_t *chars = cv->frames[f].chars;
     312            uint32_t *attrs = cv->frames[f].attrs;
    319313
    320314            for(y = 1; y < lines; y++)
     
    334328        for(f = 0; f < cv->framecount; f++)
    335329        {
    336             uint32_t *chars = cv->allchars[f];
    337             uint32_t *attrs = cv->allattrs[f];
    338             uint32_t attr = cv->curattr;
     330            uint32_t *chars = cv->frames[f].chars;
     331            uint32_t *attrs = cv->frames[f].attrs;
     332            uint32_t attr = cv->frames[f].curattr;
    339333
    340334            /* Zero the bottom of the screen */
     
    348342
    349343    /* Step 4: if new area is smaller, resize memory area now. */
    350     if(new_size <= old_size)
    351     {
    352         for(f = 0; f < cv->framecount; f++)
    353         {
    354             cv->allchars[f] = realloc(cv->allchars[f],
    355                                       new_size * sizeof(uint32_t));
    356             cv->allattrs[f] = realloc(cv->allattrs[f],
    357                                       new_size * sizeof(uint32_t));
    358             if(new_size && (!cv->allchars[f] || !cv->allattrs[f]))
     344    if(new_size < old_size)
     345    {
     346        for(f = 0; f < cv->framecount; f++)
     347        {
     348            cv->frames[f].chars = realloc(cv->frames[f].chars,
     349                                          new_size * sizeof(uint32_t));
     350            cv->frames[f].attrs = realloc(cv->frames[f].attrs,
     351                                          new_size * sizeof(uint32_t));
     352            if(new_size && (!cv->frames[f].chars || !cv->frames[f].attrs))
    359353            {
    360354#if defined(HAVE_ERRNO_H)
     
    366360    }
    367361
    368     /* Reset the current frame shortcut */
    369     cv->chars = cv->allchars[cv->frame];
    370     cv->attrs = cv->allattrs[cv->frame];
     362    /* Set new size */
     363    for(f = 0; f < cv->framecount; f++)
     364    {
     365        cv->frames[f].width = width;
     366        cv->frames[f].height = height;
     367    }
     368
     369    /* Reset the current frame shortcuts */
     370    cv->chars = cv->frames[cv->frame].chars;
     371    cv->attrs = cv->frames[cv->frame].attrs;
    371372
    372373    return 0;
  • libcaca/trunk/cucul/cucul_internals.h

    r1335 r1338  
    1919#endif
    2020
    21 struct cucul_canvas
     21struct cucul_frame
    2222{
    23     /* Canvas size */
     23    /* Frame size */
    2424    unsigned int width, height;
    2525
    26     /* Shortcut to the active frame */
     26    /* Cell information */
    2727    uint32_t *chars;
    2828    uint32_t *attrs;
    2929
     30    /* Painting context */
     31    uint32_t curattr;
     32};
     33
     34struct cucul_canvas
     35{
    3036    /* Frame information */
    3137    unsigned int frame, framecount;
    32     uint32_t **allchars;
    33     uint32_t **allattrs;
    34 
    35     /* Painting context */
    36     uint32_t curattr;
     38    struct cucul_frame *frames;
    3739
    3840    unsigned int refcount;
     41
     42    /* Shortcut to the active frame information */
     43    unsigned int width, height;
     44    uint32_t *chars;
     45    uint32_t *attrs;
     46    uint32_t curattr;
    3947};
    4048
  • libcaca/trunk/cucul/sprite.c

    r1257 r1338  
    3131#include "cucul_internals.h"
    3232
     33static void save_frame_info(cucul_canvas_t *);
     34static void load_frame_info(cucul_canvas_t *);
     35
    3336/** \brief Get the number of frames in a canvas.
    3437 *
     
    7073    }
    7174
     75    save_frame_info(cv);
    7276    cv->frame = frame;
    73 
    74     cv->chars = cv->allchars[cv->frame];
    75     cv->attrs = cv->allattrs[cv->frame];
     77    load_frame_info(cv);
    7678
    7779    return 0;
     
    8587 *  The frame index indicates where the frame should be inserted. Valid
    8688 *  values range from 0 to the current canvas frame count. If the frame
    87  *  index is greater the or equals the current canvas frame count, the new
     89 *  index is greater than or equals the current canvas frame count, the new
    8890 *  frame is appended at the end of the canvas.
    8991 *
     
    107109
    108110    cv->framecount++;
    109     cv->allchars = realloc(cv->allchars, sizeof(uint32_t *) * cv->framecount);
    110     cv->allattrs = realloc(cv->allattrs, sizeof(uint32_t *) * cv->framecount);
     111    cv->frames = realloc(cv->frames,
     112                         sizeof(struct cucul_frame) * cv->framecount);
    111113
    112114    for(f = cv->framecount - 1; f > frame; f--)
    113     {
    114         cv->allchars[f] = cv->allchars[f - 1];
    115         cv->allattrs[f] = cv->allattrs[f - 1];
    116     }
    117 
    118     cv->allchars[frame] = malloc(size);
    119     memcpy(cv->allchars[frame], cv->chars, size);
    120     cv->allattrs[frame] = malloc(size);
    121     memcpy(cv->allattrs[frame], cv->attrs, size);
     115        cv->frames[f] = cv->frames[f - 1];
     116
     117    cv->frames[frame].width = cv->width;
     118    cv->frames[frame].height = cv->height;
     119    cv->frames[frame].chars = malloc(size);
     120    memcpy(cv->frames[frame].chars, cv->chars, size);
     121    cv->frames[frame].attrs = malloc(size);
     122    memcpy(cv->frames[frame].attrs, cv->attrs, size);
     123    cv->frames[frame].curattr = cv->curattr;
    122124
    123125    if(cv->frame >= frame)
    124126        cv->frame++;
    125 
    126     cv->chars = cv->allchars[cv->frame];
    127     cv->attrs = cv->allattrs[cv->frame];
    128127
    129128    return 0;
     
    171170    }
    172171
    173     free(cv->allchars[frame]);
    174     free(cv->allattrs[frame]);
     172    free(cv->frames[frame].chars);
     173    free(cv->frames[frame].attrs);
    175174
    176175    for(f = frame + 1; f < cv->framecount; f++)
    177     {
    178         cv->allchars[f - 1] = cv->allchars[f];
    179         cv->allattrs[f - 1] = cv->allattrs[f];
    180     }
     176        cv->frames[f - 1] = cv->frames[f];
    181177
    182178    cv->framecount--;
    183     cv->allchars = realloc(cv->allchars, sizeof(uint32_t *) * cv->framecount);
    184     cv->allattrs = realloc(cv->allattrs, sizeof(uint32_t *) * cv->framecount);
     179    cv->frames = realloc(cv->frames,
     180                         sizeof(struct cucul_frame) * cv->framecount);
    185181
    186182    if(cv->frame > frame)
    187183        cv->frame--;
    188184    else if(cv->frame == frame)
     185    {
    189186        cv->frame = 0;
    190 
    191     cv->chars = cv->allchars[cv->frame];
    192     cv->attrs = cv->allattrs[cv->frame];
     187        load_frame_info(cv);
     188    }
    193189
    194190    return 0;
    195191}
    196192
     193/*
     194 * XXX: the following functions are local.
     195 */
     196
     197static void save_frame_info(cucul_canvas_t *cv)
     198{
     199    cv->frames[cv->frame].width = cv->width;
     200    cv->frames[cv->frame].height = cv->height;
     201
     202    cv->frames[cv->frame].curattr = cv->curattr;
     203}
     204
     205static void load_frame_info(cucul_canvas_t *cv)
     206{
     207    cv->width = cv->frames[cv->frame].width;
     208    cv->height = cv->frames[cv->frame].height;
     209
     210    cv->chars = cv->frames[cv->frame].chars;
     211    cv->attrs = cv->frames[cv->frame].attrs;
     212
     213    cv->curattr = cv->frames[cv->frame].curattr;
     214}
     215
Note: See TracChangeset for help on using the changeset viewer.