Changeset 235


Ignore:
Timestamp:
Nov 29, 2003, 8:35:07 PM (17 years ago)
Author:
Sam Hocevar
Message:
  • src/caca.c src/caca.h: + Added caca_get_dithering_name().
  • src/bitmap.c: + Created a new dithering method with an 8x8 ordered matrix. + Replaced the char list with a string for better readability. + Dithering functions now return a value between 0 and 255.
  • examples/demo.c examples/view.c: + Adapted to use caca_get_dithering_name().
Location:
libcaca/trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/examples/demo.c

    r226 r235  
    101101            case 'd':
    102102            case 'D':
    103                 dithering = (dithering + 1) % 3;
    104                 caca_set_dithering(dithering == 0 ? CACA_DITHER_NONE :
    105                                    dithering == 1 ? CACA_DITHER_ORDERED :
    106                                                     CACA_DITHER_RANDOM);
     103                dithering = (dithering + 1) % 4;
     104                caca_set_dithering(dithering);
    107105                display_menu();
    108106                break;
     
    204202    caca_printf(4, 18, "'b': drawing boundaries: %s",
    205203              bounds == 0 ? "screen" : "infinite");
    206     caca_printf(4, 19, "'d': %s dithering",
    207               dithering == 0 ? "no" : dithering == 1 ? "ordered" : "random");
     204    caca_printf(4, 19, "'d': dithering (%s)",
     205                caca_get_dithering_name(dithering));
    208206
    209207    caca_putstr(4, yo - 2, "'q': quit");
  • libcaca/trunk/examples/view.c

    r233 r235  
    3838int x, y, w, h;
    3939
    40 int dithering = 1;
    41 const enum caca_dithering dithering_list[] =
    42     { CACA_DITHER_NONE, CACA_DITHER_ORDERED, CACA_DITHER_RANDOM };
     40int dithering = CACA_DITHERING_ORDERED4;
    4341
    4442static void load_image(const char *);
     
    105103            case CACA_EVENT_KEY_PRESS | 'd':
    106104            case CACA_EVENT_KEY_PRESS | 'D':
    107                 dithering = (dithering + 1) % 3;
     105                dithering = (dithering + 1) % 4;
    108106                update = 1;
    109107                break;
     
    179177        {
    180178            caca_clear();
    181             caca_set_dithering(dithering_list[dithering]);
     179            caca_set_dithering(dithering);
    182180            caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);
    183181
     
    227225                              "d:Dithering  ?:Help");
    228226            caca_printf(3, wh - 1, "cacaview %s", VERSION);
     227            caca_printf(ww / 2 - 5, wh - 1, "(dithering: %s)",
     228                        caca_get_dithering_name(dithering));
    229229            caca_printf(ww - 14, wh - 1,
    230230                        "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
  • libcaca/trunk/src/bitmap.c

    r230 r235  
    5454static void increment_no_dither(void);
    5555
    56 static void init_ordered_dither(int);
    57 static int get_ordered_dither(void);
    58 static void increment_ordered_dither(void);
     56static void init_ordered4_dither(int);
     57static int get_ordered4_dither(void);
     58static void increment_ordered4_dither(void);
     59
     60static void init_ordered8_dither(int);
     61static int get_ordered8_dither(void);
     62static void increment_ordered8_dither(void);
    5963
    6064static void init_random_dither(int);
     
    6367
    6468/* Current dithering method */
    65 static enum caca_dithering _caca_dithering = CACA_DITHER_NONE;
     69static enum caca_dithering _caca_dithering = CACA_DITHERING_NONE;
    6670
    6771static void (*_init_dither) (int) = init_no_dither;
     
    7377    switch(dither)
    7478    {
    75     case CACA_DITHER_NONE:
     79    case CACA_DITHERING_NONE:
    7680        _init_dither = init_no_dither;
    7781        _get_dither = get_no_dither;
     
    7983        break;
    8084
    81     case CACA_DITHER_ORDERED:
    82         _init_dither = init_ordered_dither;
    83         _get_dither = get_ordered_dither;
    84         _increment_dither = increment_ordered_dither;
     85    case CACA_DITHERING_ORDERED4:
     86        _init_dither = init_ordered4_dither;
     87        _get_dither = get_ordered4_dither;
     88        _increment_dither = increment_ordered4_dither;
    8589        break;
    8690
    87     case CACA_DITHER_RANDOM:
     91    case CACA_DITHERING_ORDERED8:
     92        _init_dither = init_ordered8_dither;
     93        _get_dither = get_ordered8_dither;
     94        _increment_dither = increment_ordered8_dither;
     95        break;
     96
     97    case CACA_DITHERING_RANDOM:
    8898        _init_dither = init_random_dither;
    8999        _get_dither = get_random_dither;
     
    311321
    312322    static char foo[] =
    313     {
    314         ' ', ' ', ' ', ' ',
    315         ',', '`', '.', '\'',
    316         'i', '-', ':', '^',
    317         '|', '/', ';', '\\',
    318         '=', '+', 'o', 'x',
    319         '<', 'x', '%', '>',
    320         '&', 'z', '$', 'w',
    321         'W', 'X', 'K', 'M',
    322         '#', '8', '#', '#',
    323         '8', '@', '8', '#',
    324         '@', '8', '@', '8',
    325     };
     323        "    "
     324        " ,' "
     325        ",`.'"
     326        "i-:^"
     327        "|/;\\"
     328        "=+ox"
     329        "<x%>"
     330        "&z$w"
     331        "WXKM"
     332        "#8##"
     333        "8@8#"
     334        "@8@8";
    326335
    327336    int x, y, w, h, pitch;
     
    378387            rgb2hsv_default(R, G, B, &hue, &sat, &val);
    379388
    380             if(sat < 0x6000 + _get_dither() * 0x800)
     389            if(sat < 0x2000 + _get_dither() * 0x80)
    381390                caca_set_color(white_colors[val * 3 / 0x10000], CACA_COLOR_BLACK);
    382             else if(val > (_get_dither() + 40) * 0x400)
    383                 caca_set_color(light_colors[(hue + 0x8000 + _get_dither() * 0x1000) / 0x10000], CACA_COLOR_BLACK);
     391            else if(val > 0x8000 + _get_dither() * 0x40)
     392                caca_set_color(light_colors[(hue + _get_dither() * 0x100) / 0x10000], CACA_COLOR_BLACK);
    384393            else
    385                 caca_set_color(dark_colors[(hue + 0x8000 + _get_dither() * 0x1000) / 0x10000], CACA_COLOR_BLACK);
     394                caca_set_color(dark_colors[(hue + _get_dither() * 0x100) / 0x10000], CACA_COLOR_BLACK);
    386395
    387396            /* FIXME: choose better characters! */
    388             ch = (val + 0x200 * _get_dither()) * 10 / 0x10000;
    389             ch = 4 * ch + (_get_dither() + 8) / 4;
     397            ch = (val + 0x20 * _get_dither() - 0x1000 /*???*/) * 10 / 0x10000;
     398            ch = 4 * ch + (_get_dither() + 8) / 0x40;
    390399            caca_putchar(x, y, foo[ch]);
    391400
     
    409418static int get_no_dither(void)
    410419{
    411     return 0;
     420    return 0x80;
    412421}
    413422
     
    418427
    419428/*
    420  * Ordered dithering
    421  */
    422 static int dither4x4[] = {-8,  0, -6,  2,
    423                            4, -4,  6, -2,
    424                           -5,  3, -7,  1,
    425                            7, -1,  5, -3};
    426 static int *dither_table;
    427 static int dither_index;
    428 
    429 static void init_ordered_dither(int line)
    430 {
    431     dither_table = dither4x4 + (line % 4) * 4;
    432     dither_index = 0;
    433 }
    434 
    435 static int get_ordered_dither(void)
    436 {
    437     return dither_table[dither_index];
    438 }
    439 
    440 static void increment_ordered_dither(void)
    441 {
    442     dither_index = (dither_index + 1) % 4;
     429 * Ordered 4 dithering
     430 */
     431/*static int dither4x4[] = { 5,  0,  1,  6,
     432                          -1, -6, -5,  2,
     433                          -2, -7, -8,  3,
     434                           4, -3, -4, -7};*/
     435static int *ordered4_table;
     436static int ordered4_index;
     437
     438static void init_ordered4_dither(int line)
     439{
     440    static int dither4x4[] =
     441    {
     442        0x00, 0x80, 0x20, 0xa0,
     443        0xc0, 0x40, 0xe0, 0x60,
     444        0x30, 0xb0, 0x10, 0x90,
     445        0xf0, 0x70, 0xd0, 0x50
     446    };
     447
     448    ordered4_table = dither4x4 + (line % 4) * 4;
     449    ordered4_index = 0;
     450}
     451
     452static int get_ordered4_dither(void)
     453{
     454    return ordered4_table[ordered4_index];
     455}
     456
     457static void increment_ordered4_dither(void)
     458{
     459    ordered4_index = (ordered4_index + 1) % 4;
     460}
     461
     462/*
     463 * Ordered 8 dithering
     464 */
     465static int *ordered8_table;
     466static int ordered8_index;
     467
     468static void init_ordered8_dither(int line)
     469{
     470    static int dither8x8[] =
     471    {
     472        0x00, 0x80, 0x20, 0xa0, 0x08, 0x88, 0x28, 0xa8,
     473        0xc0, 0x40, 0xe0, 0x60, 0xc8, 0x48, 0xe8, 0x68,
     474        0x30, 0xb0, 0x10, 0x90, 0x38, 0xb8, 0x18, 0x98,
     475        0xf0, 0x70, 0xd0, 0x50, 0xf8, 0x78, 0xd8, 0x58,
     476        0x0c, 0x8c, 0x2c, 0xac, 0x04, 0x84, 0x24, 0xa4,
     477        0xcc, 0x4c, 0xec, 0x6c, 0xc4, 0x44, 0xe4, 0x64,
     478        0x3c, 0xbc, 0x1c, 0x9c, 0x34, 0xb4, 0x14, 0x94,
     479        0xfc, 0x7c, 0xdc, 0x5c, 0xf4, 0x74, 0xd4, 0x54,
     480    };
     481
     482    ordered8_table = dither8x8 + (line % 8) * 8;
     483    ordered8_index = 0;
     484}
     485
     486static int get_ordered8_dither(void)
     487{
     488    return ordered8_table[ordered8_index];
     489}
     490
     491static void increment_ordered8_dither(void)
     492{
     493    ordered8_index = (ordered8_index + 1) % 8;
    443494}
    444495
     
    453504static int get_random_dither(void)
    454505{
    455     return caca_rand(-8, 7);
     506    return caca_rand(0x00, 0xff);
    456507}
    457508
  • libcaca/trunk/src/caca.c

    r234 r235  
    153153}
    154154
    155 const char *caca_get_color_name(unsigned int color)
    156 {
    157     static const char *color_names[16] =
     155const char *caca_get_color_name(enum caca_color color)
     156{
     157    static const char *color_names[] =
    158158    {
    159159        "black",
     
    176176
    177177    if(color < 0 || color > 15)
    178         return "unknown color";
     178        return "unknown";
    179179
    180180    return color_names[color];
     181}
     182
     183const char *caca_get_dithering_name(enum caca_dithering dithering)
     184{
     185    static const char *dithering_names[] =
     186    {
     187        "none",
     188        "ordered 4x4",
     189        "ordered 8x8",
     190        "random"
     191    };
     192
     193    if(dithering < 0 || dithering > 3)
     194        return "unknown";
     195
     196    return dithering_names[dithering];
    181197}
    182198
  • libcaca/trunk/src/caca.h

    r226 r235  
    8282};
    8383
     84const char *caca_get_color_name(enum caca_color);
     85
    8486/**
    8587 * The dithering modes to be used with caca_set_dithering().
     
    8789enum caca_dithering
    8890{
    89     CACA_DITHER_NONE,
    90     CACA_DITHER_ORDERED,
    91     CACA_DITHER_RANDOM
    92 };
     91    CACA_DITHERING_NONE = 0,
     92    CACA_DITHERING_ORDERED4 = 1,
     93    CACA_DITHERING_ORDERED8 = 2,
     94    CACA_DITHERING_RANDOM = 3
     95};
     96
     97const char *caca_get_dithering_name(enum caca_dithering);
     98
     99/* Backwards compatibility */
     100#define CACA_DITHER_NONE    CACA_DITHERING_NONE
     101#define CACA_DITHER_ORDERED CACA_DITHERING_ORDERED8
     102#define CACA_DITHER_RANDOM  CACA_DITHERING_RANDOM
    93103
    94104/**
     
    139149unsigned int caca_get_width(void);
    140150unsigned int caca_get_height(void);
    141 const char *caca_get_color_name(unsigned int);
    142151void caca_refresh(void);
    143152void caca_end(void);
Note: See TracChangeset for help on using the changeset viewer.