Ignore:
Timestamp:
Sep 27, 2008, 3:12:46 PM (11 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.

File:
1 copied

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/caca/export.c

    r2819 r2821  
    11/*
    2  *  libcucul      Canvas for ultrafast compositing of Unicode letters
     2 *  libcaca       Colour ASCII-Art library
    33 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                2006 Jean-Yves Lamoureux <jylam@lnxscene.org>
     
    2626#endif
    2727
    28 #include "cucul.h"
    29 #include "cucul_internals.h"
     28#include "caca.h"
     29#include "caca_internals.h"
    3030
    3131static inline int sprintu32(char *s, uint32_t x)
     
    4545}
    4646
    47 static void *export_caca(cucul_canvas_t const *, size_t *);
    48 static void *export_ansi(cucul_canvas_t const *, size_t *);
    49 static void *export_utf8(cucul_canvas_t const *, size_t *, int);
    50 static void *export_html(cucul_canvas_t const *, size_t *);
    51 static void *export_html3(cucul_canvas_t const *, size_t *);
    52 static void *export_bbfr(cucul_canvas_t const *, size_t *);
    53 static void *export_irc(cucul_canvas_t const *, size_t *);
    54 static void *export_ps(cucul_canvas_t const *, size_t *);
    55 static void *export_svg(cucul_canvas_t const *, size_t *);
    56 static void *export_tga(cucul_canvas_t const *, size_t *);
     47static void *export_caca(caca_canvas_t const *, size_t *);
     48static void *export_ansi(caca_canvas_t const *, size_t *);
     49static void *export_utf8(caca_canvas_t const *, size_t *, int);
     50static void *export_html(caca_canvas_t const *, size_t *);
     51static void *export_html3(caca_canvas_t const *, size_t *);
     52static void *export_bbfr(caca_canvas_t const *, size_t *);
     53static void *export_irc(caca_canvas_t const *, size_t *);
     54static void *export_ps(caca_canvas_t const *, size_t *);
     55static void *export_svg(caca_canvas_t const *, size_t *);
     56static void *export_tga(caca_canvas_t const *, size_t *);
    5757
    5858/** \brief Export a canvas into a foreign format.
    5959 *
    60  *  This function exports a libcucul canvas into various foreign formats such
     60 *  This function exports a libcaca canvas into various foreign formats such
    6161 *  as ANSI art, HTML, IRC colours, etc. The returned pointer should be passed
    6262 *  to free() to release the allocated storage when it is no longer needed.
     
    7777 *  - \c ENOMEM Not enough memory to allocate output buffer.
    7878 *
    79  *  \param cv A libcucul canvas
     79 *  \param cv A libcaca canvas
    8080 *  \param format A string describing the requested output format.
    8181 *  \param bytes A pointer to a size_t where the number of allocated bytes
     
    8383 *  \return A pointer to the exported memory area, or NULL in case of error.
    8484 */
    85 void *cucul_export_memory(cucul_canvas_t const *cv, char const *format,
     85void *caca_export_memory(caca_canvas_t const *cv, char const *format,
    8686                          size_t *bytes)
    8787{
     
    127127 *  Return a list of available export formats. The list is a NULL-terminated
    128128 *  array of strings, interleaving a string containing the internal value for
    129  *  the export format, to be used with cucul_export_memory(), and a string
     129 *  the export format, to be used with caca_export_memory(), and a string
    130130 *  containing the natural language description for that export format.
    131131 *
     
    134134 *  \return An array of strings.
    135135 */
    136 char const * const * cucul_get_export_list(void)
     136char const * const * caca_get_export_list(void)
    137137{
    138138    static char const * const list[] =
     
    160160
    161161/* Generate a native libcaca canvas file. */
    162 static void *export_caca(cucul_canvas_t const *cv, size_t *bytes)
     162static void *export_caca(caca_canvas_t const *cv, size_t *bytes)
    163163{
    164164    char *data, *cur;
     
    213213
    214214/* Generate UTF-8 representation of current canvas. */
    215 static void *export_utf8(cucul_canvas_t const *cv, size_t *bytes,
     215static void *export_utf8(caca_canvas_t const *cv, size_t *bytes,
    216216                         int cr)
    217217{
     
    245245            uint8_t ansifg, ansibg, fg, bg;
    246246
    247             if(ch == CUCUL_MAGIC_FULLWIDTH)
     247            if(ch == CACA_MAGIC_FULLWIDTH)
    248248                continue;
    249249
    250             ansifg = cucul_attr_to_ansi_fg(attr);
    251             ansibg = cucul_attr_to_ansi_bg(attr);
     250            ansifg = caca_attr_to_ansi_fg(attr);
     251            ansibg = caca_attr_to_ansi_bg(attr);
    252252
    253253            fg = ansifg < 0x10 ? palette[ansifg] : 0x10;
     
    272272            }
    273273
    274             cur += cucul_utf32_to_utf8(cur, ch);
     274            cur += caca_utf32_to_utf8(cur, ch);
    275275
    276276            prevfg = fg;
     
    294294
    295295/* Generate ANSI representation of current canvas. */
    296 static void *export_ansi(cucul_canvas_t const *cv, size_t *bytes)
     296static void *export_ansi(caca_canvas_t const *cv, size_t *bytes)
    297297{
    298298    static uint8_t const palette[] =
     
    321321        for(x = 0; x < cv->width; x++)
    322322        {
    323             uint8_t ansifg = cucul_attr_to_ansi_fg(lineattr[x]);
    324             uint8_t ansibg = cucul_attr_to_ansi_bg(lineattr[x]);
    325             uint8_t fg = ansifg < 0x10 ? palette[ansifg] : CUCUL_LIGHTGRAY;
    326             uint8_t bg = ansibg < 0x10 ? palette[ansibg] : CUCUL_BLACK;
     323            uint8_t ansifg = caca_attr_to_ansi_fg(lineattr[x]);
     324            uint8_t ansibg = caca_attr_to_ansi_bg(lineattr[x]);
     325            uint8_t fg = ansifg < 0x10 ? palette[ansifg] : CACA_LIGHTGRAY;
     326            uint8_t bg = ansibg < 0x10 ? palette[ansibg] : CACA_BLACK;
    327327            uint32_t ch = linechar[x];
    328328
    329             if(ch == CUCUL_MAGIC_FULLWIDTH)
     329            if(ch == CACA_MAGIC_FULLWIDTH)
    330330                ch = '?';
    331331
     
    346346            }
    347347
    348             *cur++ = cucul_utf32_to_cp437(ch);
     348            *cur++ = caca_utf32_to_cp437(ch);
    349349
    350350            prevfg = fg;
     
    374374
    375375/* Generate HTML representation of current canvas. */
    376 static void *export_html(cucul_canvas_t const *cv, size_t *bytes)
     376static void *export_html(caca_canvas_t const *cv, size_t *bytes)
    377377{
    378378    char *data, *cur;
     
    391391    cur += sprintf(cur, "<html><head>\n");
    392392    cur += sprintf(cur, "<title>Generated by libcaca %s</title>\n",
    393                         cucul_get_version());
     393                        caca_get_version());
    394394    cur += sprintf(cur, "</head><body>\n");
    395395
     
    405405        {
    406406            cur += sprintf(cur, "<span style=\"");
    407             if(cucul_attr_to_ansi_fg(lineattr[x]) < 0x10)
     407            if(caca_attr_to_ansi_fg(lineattr[x]) < 0x10)
    408408                cur += sprintf(cur, ";color:#%.03x",
    409                                cucul_attr_to_rgb12_fg(lineattr[x]));
    410             if(cucul_attr_to_ansi_bg(lineattr[x]) < 0x10)
     409                               caca_attr_to_rgb12_fg(lineattr[x]));
     410            if(caca_attr_to_ansi_bg(lineattr[x]) < 0x10)
    411411                cur += sprintf(cur, ";background-color:#%.03x",
    412                                cucul_attr_to_rgb12_bg(lineattr[x]));
    413             if(lineattr[x] & CUCUL_BOLD)
     412                               caca_attr_to_rgb12_bg(lineattr[x]));
     413            if(lineattr[x] & CACA_BOLD)
    414414                cur += sprintf(cur, ";font-weight:bold");
    415             if(lineattr[x] & CUCUL_ITALICS)
     415            if(lineattr[x] & CACA_ITALICS)
    416416                cur += sprintf(cur, ";font-style:italic");
    417             if(lineattr[x] & CUCUL_UNDERLINE)
     417            if(lineattr[x] & CACA_UNDERLINE)
    418418                cur += sprintf(cur, ";text-decoration:underline");
    419             if(lineattr[x] & CUCUL_BLINK)
     419            if(lineattr[x] & CACA_BLINK)
    420420                cur += sprintf(cur, ";text-decoration:blink");
    421421            cur += sprintf(cur, "\">");
     
    425425                len++)
    426426            {
    427                 if(linechar[x + len] == CUCUL_MAGIC_FULLWIDTH)
     427                if(linechar[x + len] == CACA_MAGIC_FULLWIDTH)
    428428                    ;
    429429                else if(linechar[x + len] <= 0x00000020)
     
    456456 * will not work under gecko (mozilla rendering engine) unless you set a
    457457 * correct header. */
    458 static void *export_html3(cucul_canvas_t const *cv, size_t *bytes)
     458static void *export_html3(caca_canvas_t const *cv, size_t *bytes)
    459459{
    460460    char *data, *cur;
     
    493493            cur += sprintf(cur, "<td");
    494494
    495             if(cucul_attr_to_ansi_fg(lineattr[x]) < 0x10)
     495            if(caca_attr_to_ansi_fg(lineattr[x]) < 0x10)
    496496                cur += sprintf(cur, " bgcolor=#%.06lx", (unsigned long int)
    497                                _cucul_attr_to_rgb24bg(lineattr[x]));
     497                               _caca_attr_to_rgb24bg(lineattr[x]));
    498498
    499499            if(len > 1)
     
    502502            cur += sprintf(cur, ">");
    503503
    504             needfont = cucul_attr_to_ansi_bg(lineattr[x]) < 0x10;
     504            needfont = caca_attr_to_ansi_bg(lineattr[x]) < 0x10;
    505505
    506506            if(needfont)
    507507                cur += sprintf(cur, "<font color=#%.06lx>", (unsigned long int)
    508                                _cucul_attr_to_rgb24fg(lineattr[x]));
    509 
    510             if(lineattr[x] & CUCUL_BOLD)
     508                               _caca_attr_to_rgb24fg(lineattr[x]));
     509
     510            if(lineattr[x] & CACA_BOLD)
    511511                cur += sprintf(cur, "<b>");
    512             if(lineattr[x] & CUCUL_ITALICS)
     512            if(lineattr[x] & CACA_ITALICS)
    513513                cur += sprintf(cur, "<i>");
    514             if(lineattr[x] & CUCUL_UNDERLINE)
     514            if(lineattr[x] & CACA_UNDERLINE)
    515515                cur += sprintf(cur, "<u>");
    516             if(lineattr[x] & CUCUL_BLINK)
     516            if(lineattr[x] & CACA_BLINK)
    517517                cur += sprintf(cur, "<blink>");
    518518
    519519            for(i = 0; i < len; i++)
    520520            {
    521                 if(linechar[x + i] == CUCUL_MAGIC_FULLWIDTH)
     521                if(linechar[x + i] == CACA_MAGIC_FULLWIDTH)
    522522                    ;
    523523                else if(linechar[x + i] <= 0x00000020)
     
    529529            }
    530530
    531             if(lineattr[x] & CUCUL_BLINK)
     531            if(lineattr[x] & CACA_BLINK)
    532532                cur += sprintf(cur, "</blink>");
    533             if(lineattr[x] & CUCUL_UNDERLINE)
     533            if(lineattr[x] & CACA_UNDERLINE)
    534534                cur += sprintf(cur, "</u>");
    535             if(lineattr[x] & CUCUL_ITALICS)
     535            if(lineattr[x] & CACA_ITALICS)
    536536                cur += sprintf(cur, "</i>");
    537             if(lineattr[x] & CUCUL_BOLD)
     537            if(lineattr[x] & CACA_BOLD)
    538538                cur += sprintf(cur, "</b>");
    539539
     
    557557}
    558558
    559 static void *export_bbfr(cucul_canvas_t const *cv, size_t *bytes)
     559static void *export_bbfr(caca_canvas_t const *cv, size_t *bytes)
    560560{
    561561    char *data, *cur;
     
    595595                    len++;
    596596
    597             needback = cucul_attr_to_ansi_bg(lineattr[x]) < 0x10;
    598             needfront = cucul_attr_to_ansi_fg(lineattr[x]) < 0x10;
     597            needback = caca_attr_to_ansi_bg(lineattr[x]) < 0x10;
     598            needfront = caca_attr_to_ansi_fg(lineattr[x]) < 0x10;
    599599
    600600            if(needback)
    601601                cur += sprintf(cur, "[f=#%.06lx]", (unsigned long int)
    602                                _cucul_attr_to_rgb24bg(lineattr[x]));
     602                               _caca_attr_to_rgb24bg(lineattr[x]));
    603603
    604604            if(linechar[x] == ' ')
    605605                cur += sprintf(cur, "[c=#%.06lx]", (unsigned long int)
    606                                _cucul_attr_to_rgb24bg(lineattr[x]));
     606                               _caca_attr_to_rgb24bg(lineattr[x]));
    607607            else if(needfront)
    608608                cur += sprintf(cur, "[c=#%.06lx]", (unsigned long int)
    609                                _cucul_attr_to_rgb24fg(lineattr[x]));
    610 
    611             if(lineattr[x] & CUCUL_BOLD)
     609                               _caca_attr_to_rgb24fg(lineattr[x]));
     610
     611            if(lineattr[x] & CACA_BOLD)
    612612                cur += sprintf(cur, "[g]");
    613             if(lineattr[x] & CUCUL_ITALICS)
     613            if(lineattr[x] & CACA_ITALICS)
    614614                cur += sprintf(cur, "[i]");
    615             if(lineattr[x] & CUCUL_UNDERLINE)
     615            if(lineattr[x] & CACA_UNDERLINE)
    616616                cur += sprintf(cur, "[s]");
    617             if(lineattr[x] & CUCUL_BLINK)
     617            if(lineattr[x] & CACA_BLINK)
    618618                ; /* FIXME */
    619619
    620620            for(i = 0; i < len; i++)
    621621            {
    622                 if(linechar[x + i] == CUCUL_MAGIC_FULLWIDTH)
     622                if(linechar[x + i] == CACA_MAGIC_FULLWIDTH)
    623623                    ;
    624624                else if(linechar[x + i] == ' ')
    625625                    *cur++ = '_';
    626626                else
    627                     cur += cucul_utf32_to_utf8(cur, linechar[x + i]);
     627                    cur += caca_utf32_to_utf8(cur, linechar[x + i]);
    628628            }
    629629
    630             if(lineattr[x] & CUCUL_BLINK)
     630            if(lineattr[x] & CACA_BLINK)
    631631                ; /* FIXME */
    632             if(lineattr[x] & CUCUL_UNDERLINE)
     632            if(lineattr[x] & CACA_UNDERLINE)
    633633                cur += sprintf(cur, "[/s]");
    634             if(lineattr[x] & CUCUL_ITALICS)
     634            if(lineattr[x] & CACA_ITALICS)
    635635                cur += sprintf(cur, "[/i]");
    636             if(lineattr[x] & CUCUL_BOLD)
     636            if(lineattr[x] & CACA_BOLD)
    637637                cur += sprintf(cur, "[/g]");
    638638
     
    658658
    659659/* Export a text file with IRC colours */
    660 static void *export_irc(cucul_canvas_t const *cv, size_t *bytes)
     660static void *export_irc(caca_canvas_t const *cv, size_t *bytes)
    661661{
    662662    static uint8_t const palette[] =
     
    696696            uint8_t ansifg, ansibg, fg, bg;
    697697
    698             if(ch == CUCUL_MAGIC_FULLWIDTH)
     698            if(ch == CACA_MAGIC_FULLWIDTH)
    699699                continue;
    700700
    701             ansifg = cucul_attr_to_ansi_fg(attr);
    702             ansibg = cucul_attr_to_ansi_bg(attr);
     701            ansifg = caca_attr_to_ansi_fg(attr);
     702            ansibg = caca_attr_to_ansi_bg(attr);
    703703
    704704            fg = ansifg < 0x10 ? palette[ansifg] : 0x10;
     
    742742            }
    743743
    744             cur += cucul_utf32_to_utf8(cur, ch);
     744            cur += caca_utf32_to_utf8(cur, ch);
    745745            prevfg = fg;
    746746            prevbg = bg;
     
    765765
    766766/* Export a PostScript document. */
    767 static void *export_ps(cucul_canvas_t const *cv, size_t *bytes)
     767static void *export_ps(caca_canvas_t const *cv, size_t *bytes)
    768768{
    769769    static char const *ps_header =
     
    811811        {
    812812            uint8_t argb[8];
    813             cucul_attr_to_argb64(*lineattr++, argb);
     813            caca_attr_to_argb64(*lineattr++, argb);
    814814            cur += sprintf(cur, "1 0 translate\n %f %f %f csquare\n",
    815815                           (float)argb[1] * (1.0 / 0xf),
     
    835835            uint32_t ch = *linechar++;
    836836
    837             cucul_attr_to_argb64(*lineattr++, argb);
     837            caca_attr_to_argb64(*lineattr++, argb);
    838838
    839839            cur += sprintf(cur, "newpath\n");
     
    874874
    875875/* Export an SVG vector image */
    876 static void *export_svg(cucul_canvas_t const *cv, size_t *bytes)
     876static void *export_svg(caca_canvas_t const *cv, size_t *bytes)
    877877{
    878878    static char const svg_header[] =
     
    906906            cur += sprintf(cur, "<rect style=\"fill:#%.03x\" x=\"%d\" y=\"%d\""
    907907                                " width=\"6\" height=\"10\"/>\n",
    908                                 cucul_attr_to_rgb12_bg(*lineattr++),
     908                                caca_attr_to_rgb12_bg(*lineattr++),
    909909                                x * 6, y * 10);
    910910        }
     
    921921            uint32_t ch = *linechar++;
    922922
    923             if(ch == ' ' || ch == CUCUL_MAGIC_FULLWIDTH)
     923            if(ch == ' ' || ch == CACA_MAGIC_FULLWIDTH)
    924924            {
    925925                lineattr++;
     
    929929            cur += sprintf(cur, "<text style=\"fill:#%.03x\" "
    930930                                "x=\"%d\" y=\"%d\">",
    931                                 cucul_attr_to_rgb12_fg(*lineattr++),
     931                                caca_attr_to_rgb12_fg(*lineattr++),
    932932                                x * 6, (y * 10) + 8);
    933933
     
    935935                *cur++ = '?';
    936936            else if(ch > 0x0000007f)
    937                 cur += cucul_utf32_to_utf8(cur, ch);
     937                cur += caca_utf32_to_utf8(cur, ch);
    938938            else switch((uint8_t)ch)
    939939            {
     
    960960
    961961/* Export a TGA image */
    962 static void *export_tga(cucul_canvas_t const *cv, size_t *bytes)
     962static void *export_tga(caca_canvas_t const *cv, size_t *bytes)
    963963{
    964964    char const * const *fontlist;
    965965    char *data, *cur;
    966     cucul_font_t *f;
     966    caca_font_t *f;
    967967    int i, w, h;
    968968
    969     fontlist = cucul_get_font_list();
     969    fontlist = caca_get_font_list();
    970970    if(!fontlist[0])
    971971    {
     
    974974    }
    975975
    976     f = cucul_load_font(fontlist[0], 0);
    977 
    978     w = cucul_get_canvas_width(cv) * cucul_get_font_width(f);
    979     h = cucul_get_canvas_height(cv) * cucul_get_font_height(f);
     976    f = caca_load_font(fontlist[0], 0);
     977
     978    w = caca_get_canvas_width(cv) * caca_get_font_width(f);
     979    h = caca_get_canvas_height(cv) * caca_get_font_height(f);
    980980
    981981    *bytes = w * h * 4 + 18; /* 32 bpp + 18 bytes for the header */
     
    10031003
    10041004    /* Image Data */
    1005     cucul_render_canvas(cv, f, cur, w, h, 4 * w);
     1005    caca_render_canvas(cv, f, cur, w, h, 4 * w);
    10061006
    10071007    /* Swap bytes. What a waste of time. */
     
    10131013    }
    10141014
    1015     cucul_free_font(f);
     1015    caca_free_font(f);
    10161016
    10171017    return data;
Note: See TracChangeset for help on using the changeset viewer.