cacalabs
/
libcaca
şunun yansıması https://github.com/cacalabs/libcaca.git
1
0
Çatalla 0
Kod Konular 0 Sürümler 7 Wiki Aktivite
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.
1996 İşleme
1 Dal
4.9 MiB
 
 
 
 
 
 
Ağaç: a18e28d43e
Dallar Biçim İmleri
${ item.name }
${ searchTerm } dalı oluştur
'a18e28d43e'den
${ noResults }
libcaca/caca/codec/export.c

1100 satır
37 KiB
Ham Suçlama Geçmiş 

  1. /*

  2.  *  libcaca     Colour ASCII-Art library

  3.  *  Copyright © 2002—2021 Sam Hocevar <sam@hocevar.net>

  4.  *              2006 Jean-Yves Lamoureux <jylam@lnxscene.org>

  5.  *              All Rights Reserved

  6.  *

  7.  *  This library is free software. It comes without any warranty, to

  8.  *  the extent permitted by applicable law. You can redistribute it

  9.  *  and/or modify it under the terms of the Do What the Fuck You Want

  10.  *  to Public License, Version 2, as published by Sam Hocevar. See

  11.  *  http://www.wtfpl.net/ for more details.

  12.  */

  13. 

  14. /*

  15.  *  This file contains various export functions

  16.  */

  17. 

  18. #include "config.h"

  19. 

  20. #if !defined(__KERNEL__)

  21. #   include <stdlib.h>

  22. #   include <stdio.h>

  23. #   include <string.h>

  24. #endif

  25. 

  26. #include "caca.h"

  27. #include "caca_internals.h"

  28. #include "codec.h"

  29. 

  30. /* Big endian */

  31. static inline int sprintu32(char *s, uint32_t x)

  32. {

  33.     s[0] = (uint8_t)(x >> 24);

  34.     s[1] = (uint8_t)(x >> 16) & 0xff;

  35.     s[2] = (uint8_t)(x >>  8) & 0xff;

  36.     s[3] = (uint8_t)(x      ) & 0xff;

  37.     return 4;

  38. }

  39. 

  40. /* Big endian */

  41. static inline int sprintu16(char *s, uint16_t x)

  42. {

  43.     s[0] = (uint8_t)(x >>  8) & 0xff;

  44.     s[1] = (uint8_t)(x      ) & 0xff;

  45.     return 2;

  46. }

  47. 

  48. static inline int write_u8(char *s, uint8_t x)

  49. {

  50.     s[0] = x;

  51.     return 1;

  52. }

  53. 

  54. static inline int write_string(char *s, char const *d)

  55. {

  56.     int n = 0;

  57.     for (; d[n]; ++n)

  58.         s[n] = d[n];

  59.     return n;

  60. }

  61. 

  62. static void *export_caca(caca_canvas_t const *, size_t *);

  63. static void *export_html(caca_canvas_t const *, size_t *);

  64. static void *export_html3(caca_canvas_t const *, size_t *);

  65. static void *export_bbfr(caca_canvas_t const *, size_t *);

  66. static void *export_ps(caca_canvas_t const *, size_t *);

  67. static void *export_svg(caca_canvas_t const *, size_t *);

  68. static void *export_tga(caca_canvas_t const *, size_t *);

  69. static void *export_troff(caca_canvas_t const *, size_t *);

  70. 

  71. /** \brief Export a canvas into a foreign format.

  72.  *

  73.  *  This function exports a libcaca canvas into various foreign formats such

  74.  *  as ANSI art, HTML, IRC colours, etc. The returned pointer should be passed

  75.  *  to free() to release the allocated storage when it is no longer needed.

  76.  *

  77.  *  Valid values for \c format are:

  78.  *  - \c "caca": export native libcaca files.

  79.  *  - \c "ansi": export ANSI art (CP437 charset with ANSI colour codes).

  80.  *  - \c "html": export an HTML page with CSS information.

  81.  *  - \c "html3": export an HTML table that should be compatible with

  82.  *    most navigators, including textmode ones.

  83.  *  - \c "irc": export UTF-8 text with mIRC colour codes.

  84.  *  - \c "ps": export a PostScript document.

  85.  *  - \c "svg": export an SVG vector image.

  86.  *  - \c "tga": export a TGA image.

  87.  *  - \c "troff": export a troff source.

  88.  *

  89.  *  If an error occurs, NULL is returned and \b errno is set accordingly:

  90.  *  - \c EINVAL Unsupported format requested.

  91.  *  - \c ENOMEM Not enough memory to allocate output buffer.

  92.  *

  93.  *  \param cv A libcaca canvas

  94.  *  \param format A string describing the requested output format.

  95.  *  \param bytes A pointer to a size_t where the number of allocated bytes

  96.  *         will be written.

  97.  *  \return A pointer to the exported memory area, or NULL in case of error.

  98.  */

  99. void *caca_export_canvas_to_memory(caca_canvas_t const *cv, char const *format,

  100.                                    size_t *bytes)

  101. {

  102.     if(!strcasecmp("caca", format))

  103.         return export_caca(cv, bytes);

  104. 

  105.     if(!strcasecmp("ansi", format))

  106.         return _export_ansi(cv, bytes);

  107. 

  108.     if(!strcasecmp("utf8", format))

  109.         return _export_utf8(cv, bytes, 0);

  110. 

  111.     if(!strcasecmp("utf8cr", format))

  112.         return _export_utf8(cv, bytes, 1);

  113. 

  114.     if(!strcasecmp("html", format))

  115.         return export_html(cv, bytes);

  116. 

  117.     if(!strcasecmp("html3", format))

  118.         return export_html3(cv, bytes);

  119. 

  120.     if(!strcasecmp("bbfr", format))

  121.         return export_bbfr(cv, bytes);

  122. 

  123.     if(!strcasecmp("irc", format))

  124.         return _export_irc(cv, bytes);

  125. 

  126.     if(!strcasecmp("ps", format))

  127.         return export_ps(cv, bytes);

  128. 

  129.     if(!strcasecmp("svg", format))

  130.         return export_svg(cv, bytes);

  131. 

  132.     if(!strcasecmp("tga", format))

  133.         return export_tga(cv, bytes);

  134. 

  135.     if(!strcasecmp("troff", format))

  136.         return export_troff(cv, bytes);

  137. 

  138.     seterrno(EINVAL);

  139.     return NULL;

  140. }

  141. 

  142. /** \brief Export a canvas portion into a foreign format.

  143.  *

  144.  *  This function exports a portion of a \e libcaca canvas into various

  145.  *  formats. For more information, see caca_export_canvas_to_memory().

  146.  *

  147.  *  If an error occurs, NULL is returned and \b errno is set accordingly:

  148.  *  - \c EINVAL Unsupported format requested or invalid coordinates.

  149.  *  - \c ENOMEM Not enough memory to allocate output buffer.

  150.  *

  151.  *  \param cv A libcaca canvas

  152.  *  \param x The leftmost coordinate of the area to export.

  153.  *  \param y The topmost coordinate of the area to export.

  154.  *  \param w The width of the area to export.

  155.  *  \param h The height of the area to export.

  156.  *  \param format A string describing the requested output format.

  157.  *  \param bytes A pointer to a size_t where the number of allocated bytes

  158.  *         will be written.

  159.  *  \return A pointer to the exported memory area, or NULL in case of error.

  160.  */

  161. void *caca_export_area_to_memory(caca_canvas_t const *cv, int x, int y, int w,

  162.                                  int h, char const *format, size_t *bytes)

  163. {

  164.     caca_canvas_t *tmp;

  165.     void *ret;

  166. 

  167.     if(w < 0 || h < 0 || x < 0 || y < 0

  168.         || x + w > cv->width || y + h > cv->height)

  169.     {

  170.         seterrno(EINVAL);

  171.         return NULL;

  172.     }

  173. 

  174.     /* TODO: we need to spare the blit here by exporting the area we want. */

  175.     tmp = caca_create_canvas(w, h);

  176.     caca_blit(tmp, -x, -y, cv, NULL);

  177. 

  178.     ret = caca_export_canvas_to_memory(tmp, format, bytes);

  179. 

  180.     caca_free_canvas(tmp);

  181. 

  182.     return ret;

  183. }

  184. 

  185. /** \brief Get available export formats

  186.  *

  187.  *  Return a list of available export formats. The list is a NULL-terminated

  188.  *  array of strings, interleaving a string containing the internal value for

  189.  *  the export format, to be used with caca_export_memory(), and a string

  190.  *  containing the natural language description for that export format.

  191.  *

  192.  *  This function never fails.

  193.  *

  194.  *  \return An array of strings.

  195.  */

  196. char const * const * caca_get_export_list(void)

  197. {

  198.     static char const * const list[] =

  199.     {

  200.         "caca", "native libcaca format",

  201.         "ansi", "ANSI",

  202.         "utf8", "UTF-8 with ANSI escape codes",

  203.         "utf8cr", "UTF-8 with ANSI escape codes and MS-DOS \\r",

  204.         "html", "HTML",

  205.         "html3", "backwards-compatible HTML",

  206.         "bbfr", "BBCode (French)",

  207.         "irc", "IRC with mIRC colours",

  208.         "ps", "PostScript document",

  209.         "svg", "SVG vector image",

  210.         "tga", "TGA image",

  211.         "troff", "troff source",

  212.         NULL, NULL

  213.     };

  214. 

  215.     return list;

  216. }

  217. 

  218. /*

  219.  * XXX: the following functions are local.

  220.  */

  221. 

  222. /* Generate a native libcaca canvas file. */

  223. static void *export_caca(caca_canvas_t const *cv, size_t *bytes)

  224. {

  225.     char *data, *cur;

  226.     int f, n;

  227. 

  228.     /* 52 bytes for the header:

  229.      *  - 4 bytes for "\xCA\xCA" + "CV"

  230.      *  - 16 bytes for the canvas header

  231.      *  - 32 bytes for the frame info

  232.      * 8 bytes for each character cell */

  233.     *bytes = 20 + (32 + 8 * cv->width * cv->height) * cv->framecount;

  234.     cur = data = malloc(*bytes);

  235. 

  236.     /* magic */

  237.     cur += sprintf(cur, "%s", "\xCA\xCA" "CV");

  238. 

  239.     /* canvas_header */

  240.     cur += sprintu32(cur, 16 + 32 * cv->framecount);

  241.     cur += sprintu32(cur, cv->width * cv->height * 8 * cv->framecount);

  242.     cur += sprintu16(cur, 0x0001);

  243.     cur += sprintu32(cur, cv->framecount);

  244.     cur += sprintu16(cur, 0x0000);

  245. 

  246.     /* frame_info */

  247.     for(f = 0; f < cv->framecount; f++)

  248.     {

  249.         cur += sprintu32(cur, cv->width);

  250.         cur += sprintu32(cur, cv->height);

  251.         cur += sprintu32(cur, 0);

  252.         cur += sprintu32(cur, cv->curattr);

  253.         cur += sprintu32(cur, cv->frames[f].x);

  254.         cur += sprintu32(cur, cv->frames[f].y);

  255.         cur += sprintu32(cur, cv->frames[f].handlex);

  256.         cur += sprintu32(cur, cv->frames[f].handley);

  257.     }

  258. 

  259.     /* canvas_data */

  260.     for(f = 0; f < cv->framecount; f++)

  261.     {

  262.         uint32_t *attrs = cv->frames[f].attrs;

  263.         uint32_t *chars = cv->frames[f].chars;

  264. 

  265.         for(n = cv->height * cv->width; n--; )

  266.         {

  267.             cur += sprintu32(cur, *chars++);

  268.             cur += sprintu32(cur, *attrs++);

  269.         }

  270.     }

  271. 

  272.     return data;

  273. }

  274. 

  275. /* Generate HTML representation of current canvas. */

  276. static void *export_html(caca_canvas_t const *cv, size_t *bytes)

  277. {

  278.     char *data, *cur;

  279.     int x, y, len;

  280. 

  281.     /* The HTML header: less than 1000 bytes

  282.      * A line: 7 chars for "<br />\n"

  283.      * A glyph: 47 chars for "<span style="color:#xxx;background-color:#xxx">"

  284.      *          83 chars for ";font-weight..."

  285.      *          up to 10 chars for "&#xxxxxxx;", far less for pure ASCII

  286.      *          7 chars for "</span>" */

  287.     *bytes = 1000 + cv->height * (7 + cv->width * (47 + 83 + 10 + 7));

  288.     cur = data = malloc(*bytes);

  289. 

  290.     /* HTML header */

  291. 

  292.     cur += sprintf(cur, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n");

  293.     cur += sprintf(cur, "   \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n");

  294.     cur += sprintf(cur, "<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"en\" xml:lang=\"en\">");

  295.     cur += sprintf(cur, "<head>\n");

  296.     cur += sprintf(cur, "<title>Generated by libcaca %s</title>\n",

  297.                         caca_get_version());

  298.     cur += sprintf(cur, "</head><body>\n");

  299. 

  300.     cur += sprintf(cur, "<div style=\"%s\">\n",

  301.                         "font-family: monospace, fixed; font-weight: bold;");

  302. 

  303.     for(y = 0; y < cv->height; y++)

  304.     {

  305.         uint32_t *lineattr = cv->attrs + y * cv->width;

  306.         uint32_t *linechar = cv->chars + y * cv->width;

  307. 

  308.         for(x = 0; x < cv->width; x += len)

  309.         {

  310.             cur += sprintf(cur, "<span style=\"");

  311.             if(caca_attr_to_ansi_fg(lineattr[x]) != CACA_DEFAULT)

  312.                 cur += sprintf(cur, ";color:#%.03x",

  313.                                caca_attr_to_rgb12_fg(lineattr[x]));

  314.             if(caca_attr_to_ansi_bg(lineattr[x]) < 0x10)

  315.                 cur += sprintf(cur, ";background-color:#%.03x",

  316.                                caca_attr_to_rgb12_bg(lineattr[x]));

  317.             if(lineattr[x] & CACA_BOLD)

  318.                 cur += sprintf(cur, ";font-weight:bold");

  319.             if(lineattr[x] & CACA_ITALICS)

  320.                 cur += sprintf(cur, ";font-style:italic");

  321.             if(lineattr[x] & CACA_UNDERLINE)

  322.                 cur += sprintf(cur, ";text-decoration:underline");

  323.             if(lineattr[x] & CACA_BLINK)

  324.                 cur += sprintf(cur, ";text-decoration:blink");

  325.             cur += sprintf(cur, "\">");

  326. 

  327.             for(len = 0;

  328.                 x + len < cv->width && lineattr[x + len] == lineattr[x];

  329.                 len++)

  330.             {

  331.                 if(linechar[x + len] == CACA_MAGIC_FULLWIDTH)

  332.                     ;

  333.                 else if((linechar[x + len] <= 0x00000020)

  334.                         ||

  335.                         ((linechar[x + len] >= 0x0000007f)

  336.                          &&

  337.                          (linechar[x + len] <= 0x000000a0)))

  338.                 {

  339.                     /* Control characters and space converted to

  340.                      * U+00A0 NO-BREAK SPACE, a.k.a. "&nbsp;" in HTML,

  341.                      * but we use the equivalent numeric character

  342.                      * reference &#160; so this will work in plain

  343.                      * XHTML with no DTD too. */

  344.                     cur += sprintf(cur, "&#160;");

  345.                 }

  346.                 else if(linechar[x + len] == '&')

  347.                     cur += sprintf(cur, "&amp;");

  348.                 else if(linechar[x + len] == '<')

  349.                     cur += sprintf(cur, "&lt;");

  350.                 else if(linechar[x + len] == '>')

  351.                     cur += sprintf(cur, "&gt;");

  352.                 else if(linechar[x + len] == '\"')

  353.                     cur += sprintf(cur, "&quot;");

  354.                 else if(linechar[x + len] == '\'')

  355.                     cur += sprintf(cur, "&#39;");

  356.                 else if(linechar[x + len] < 0x00000080)

  357.                     cur += write_u8(cur, (uint8_t)linechar[x + len]);

  358.                 else if((linechar[x + len] <= 0x0010fffd)

  359.                         &&

  360.                         ((linechar[x + len] & 0x0000fffe) != 0x0000fffe)

  361.                         &&

  362.                         ((linechar[x + len] < 0x0000d800)

  363.                          ||

  364.                          (linechar[x + len] > 0x0000dfff)))

  365.                     cur += sprintf(cur, "&#%i;", (unsigned int)linechar[x + len]);

  366.                 else

  367.                     /* non-character codepoints become U+FFFD

  368.                      * REPLACEMENT CHARACTER */

  369.                     cur += sprintf(cur, "&#%i;", (unsigned int)0x0000fffd);

  370.             }

  371.             cur += sprintf(cur, "</span>");

  372.         }

  373.         /* New line */

  374.         cur += sprintf(cur, "<br />\n");

  375.     }

  376. 

  377.     cur += sprintf(cur, "</div></body></html>\n");

  378. 

  379.     /* Crop to really used size */

  380.     debug("html export: alloc %lu bytes, realloc %lu",

  381.           (unsigned long int)*bytes, (unsigned long int)(cur - data));

  382.     *bytes = (uintptr_t)(cur - data);

  383.     data = realloc(data, *bytes);

  384. 

  385.     return data;

  386. }

  387. 

  388. /* Export an HTML3 document. This function is way bigger than export_html(),

  389.  * but permits viewing in old browsers (or limited ones such as links). It

  390.  * will not work under gecko (mozilla rendering engine) unless you set a

  391.  * correct header. */

  392. static void *export_html3(caca_canvas_t const *cv, size_t *bytes)

  393. {

  394.     char *data, *cur;

  395.     int x, y, len;

  396.     int has_multi_cell_row = 0;

  397.     unsigned char *cell_boundary_bitmap;

  398. 

  399.     /* Table */

  400.     cell_boundary_bitmap = (unsigned char *) malloc((cv->width + 7) / 8);

  401.     if(cell_boundary_bitmap)

  402.         memset((void *) cell_boundary_bitmap, 0, (cv->width + 7) / 8);

  403.     for(y = 0; y < cv->height; y++)

  404.     {

  405.         uint32_t *lineattr = cv->attrs + y * cv->width;

  406.         uint32_t *linechar = cv->chars + y * cv->width;

  407. 

  408.         for(x = 1; x < cv->width; x++)

  409.             if((! (cell_boundary_bitmap

  410.                    ?

  411.                    (cell_boundary_bitmap[x / 8] & (1 << (x % 8)))

  412.                    :

  413.                    has_multi_cell_row))

  414.                &&

  415.                (((linechar[x - 1] == CACA_MAGIC_FULLWIDTH)

  416.                  &&

  417.                  (! caca_utf32_is_fullwidth(linechar[x])))

  418.                 ||

  419.                 (caca_attr_to_ansi_bg(lineattr[x - 1])

  420.                  !=

  421.                  caca_attr_to_ansi_bg(lineattr[x]))

  422.                 ||

  423.                 ((caca_attr_to_ansi_bg(lineattr[x]) < 0x10)

  424.                  ?

  425.                  (_caca_attr_to_rgb24bg(lineattr[x - 1])

  426.                   !=

  427.                   _caca_attr_to_rgb24bg(lineattr[x]))

  428.                  :

  429.                  0)))

  430.             {

  431.                 has_multi_cell_row = 1;

  432.                 if(cell_boundary_bitmap)

  433.                     cell_boundary_bitmap[x / 8] |= 1 << (x % 8);

  434.             }

  435.     }

  436. 

  437.     /* The HTML table markup: less than 1000 bytes

  438.      * A line: 10 chars for "<tr></tr>\n"

  439.      * A glyph: up to 48 chars for "<td bgcolor=\"#xxxxxx\"><tt><font color=\"#xxxxxx\">"

  440.      *          up to 36 chars for "<b><i><u><blink></blink></u></i></b>"

  441.      *          up to 10 chars for "&#xxxxxxx;" (far less for pure ASCII)

  442.      *          17 chars for "</font></tt></td>" */

  443.     *bytes = 1000 + cv->height * (10 + cv->width * (48 + 36 + 10 + 17));

  444.     cur = data = malloc(*bytes);

  445. 

  446.     cur += sprintf(cur, "<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" summary=\"[libcaca canvas export]\">\n");

  447. 

  448.     for(y = 0; y < cv->height; y++)

  449.     {

  450.         uint32_t *lineattr = cv->attrs + y * cv->width;

  451.         uint32_t *linechar = cv->chars + y * cv->width;

  452. 

  453.         cur += sprintf(cur, "<tr>");

  454. 

  455.         for(x = 0; x < cv->width; x += len)

  456.         {

  457.             int i, needfont = 0;

  458.             int nonblank = 0;

  459. 

  460.             /* Use colspan option to factor cells with same attributes

  461.              * (see below) */

  462.             len = 1;

  463.             while((x + len < cv->width)

  464.                   &&

  465.                   ((y

  466.                     &&

  467.                     (linechar[x + len] > 0x00000020)

  468.                     &&

  469.                     ((linechar[x + len] < 0x0000007f)

  470.                      ||

  471.                      (linechar[x + len] > 0x000000a0)))

  472.                    ||

  473.                    (! (cell_boundary_bitmap

  474.                        ?

  475.                        (cell_boundary_bitmap[(x + len) / 8] & (1 << ((x + len) % 8)))

  476.                        :

  477.                        has_multi_cell_row))

  478.                    ||

  479.                    (linechar[x + len] == CACA_MAGIC_FULLWIDTH)

  480.                    ||

  481.                    (cv->height == 1))

  482.                   &&

  483.                   ((linechar[x + len - 1] != CACA_MAGIC_FULLWIDTH)

  484.                    ||

  485.                    caca_utf32_is_fullwidth(linechar[x + len]))

  486.                   &&

  487.                   (caca_attr_to_ansi_bg(lineattr[x + len])

  488.                    ==

  489.                    caca_attr_to_ansi_bg(lineattr[x]))

  490.                   &&

  491.                   ((caca_attr_to_ansi_bg(lineattr[x]) < 0x10)

  492.                    ?

  493.                    (_caca_attr_to_rgb24bg(lineattr[x + len])

  494.                     ==

  495.                     _caca_attr_to_rgb24bg(lineattr[x]))

  496.                    :

  497.                    1))

  498.                 len++;

  499. 

  500.             for(i = 0; i < len; i++)

  501.                 if(! ((linechar[x + i] <= 0x00000020)

  502.                       ||

  503.                       ((linechar[x + i] >= 0x0000007f)

  504.                        &&

  505.                        (linechar[x + i] <= 0x000000a0))))

  506.                     nonblank = 1;

  507. 

  508.             cur += sprintf(cur, "<td");

  509. 

  510.             if(caca_attr_to_ansi_bg(lineattr[x]) < 0x10)

  511.                 cur += sprintf(cur, " bgcolor=\"#%.06lx\"", (unsigned long int)

  512.                                _caca_attr_to_rgb24bg(lineattr[x]));

  513. 

  514.             if(has_multi_cell_row && (len > 1))

  515.             {

  516.                 int colspan;

  517. 

  518.                 colspan = len;

  519.                 if(cell_boundary_bitmap)

  520.                     for(i = 0; i < len; i ++)

  521.                         if(i

  522.                            &&

  523.                            ! (cell_boundary_bitmap[(x + i) / 8]

  524.                               &

  525.                               (1 << ((x + i) % 8))))

  526.                             colspan --;

  527.                 if(colspan > 1)

  528.                     cur += sprintf(cur, " colspan=\"%d\"", colspan);

  529.             }

  530. 

  531.             cur += sprintf(cur, ">");

  532. 

  533.             cur += sprintf(cur, "<tt>");

  534. 

  535.             for(i = 0; i < len; i++)

  536.             {

  537.                 if(nonblank

  538.                    &&

  539.                    ((! i)

  540.                     ||

  541.                     (lineattr[x + i] != lineattr[x + i - 1])))

  542.                 {

  543.                     needfont = (caca_attr_to_ansi_fg(lineattr[x + i])

  544.                                 !=

  545.                                 CACA_DEFAULT);

  546. 

  547.                     if(needfont)

  548.                         cur += sprintf(cur, "<font color=\"#%.06lx\">",

  549.                                        (unsigned long int)

  550.                                        _caca_attr_to_rgb24fg(lineattr[x + i]));

  551. 

  552.                     if(lineattr[x + i] & CACA_BOLD)

  553.                         cur += sprintf(cur, "<b>");

  554.                     if(lineattr[x + i] & CACA_ITALICS)

  555.                         cur += sprintf(cur, "<i>");

  556.                     if(lineattr[x + i] & CACA_UNDERLINE)

  557.                         cur += sprintf(cur, "<u>");

  558.                     if(lineattr[x + i] & CACA_BLINK)

  559.                         cur += sprintf(cur, "<blink>");

  560.                 }

  561. 

  562.                 if(linechar[x + i] == CACA_MAGIC_FULLWIDTH)

  563.                     ;

  564.                 else if((linechar[x + i] <= 0x00000020)

  565.                         ||

  566.                         ((linechar[x + i] >= 0x0000007f)

  567.                          &&

  568.                          (linechar[x + i] <= 0x000000a0)))

  569.                 {

  570.                     /* Control characters and space converted to

  571.                      * U+00A0 NO-BREAK SPACE, a.k.a. "&nbsp;" in HTML,

  572.                      * but we use the equivalent numeric character

  573.                      * reference &#160; so this will work in plain

  574.                      * XHTML with no DTD too. */

  575.                     cur += sprintf(cur, "&#160;");

  576.                 }

  577.                 else if(linechar[x + i] == '&')

  578.                     cur += sprintf(cur, "&amp;");

  579.                 else if(linechar[x + i] == '<')

  580.                     cur += sprintf(cur, "&lt;");

  581.                 else if(linechar[x + i] == '>')

  582.                     cur += sprintf(cur, "&gt;");

  583.                 else if(linechar[x + i] == '\"')

  584.                     cur += sprintf(cur, "&quot;");

  585.                 else if(linechar[x + i] == '\'')

  586.                     cur += sprintf(cur, "&#39;");

  587.                 else if(linechar[x + i] < 0x00000080)

  588.                     cur += write_u8(cur, (uint8_t)linechar[x + i]);

  589.                 else if((linechar[x + i] <= 0x0010fffd)

  590.                         &&

  591.                         ((linechar[x + i] & 0x0000fffe) != 0x0000fffe)

  592.                         &&

  593.                         ((linechar[x + i] < 0x0000d800)

  594.                          ||

  595.                          (linechar[x + i] > 0x0000dfff)))

  596.                     cur += sprintf(cur, "&#%i;", (unsigned int)linechar[x + i]);

  597.                 else

  598.                     /* non-character codepoints become U+FFFD

  599.                      * REPLACEMENT CHARACTER */

  600.                     cur += sprintf(cur, "&#%i;", (unsigned int)0x0000fffd);

  601. 

  602.                 if (nonblank

  603.                     &&

  604.                     (((i + 1) == len)

  605.                      ||

  606.                      (lineattr[x + i + 1] != lineattr[x + i])))

  607.                 {

  608.                     if(lineattr[x + i] & CACA_BLINK)

  609.                         cur += sprintf(cur, "</blink>");

  610.                     if(lineattr[x + i] & CACA_UNDERLINE)

  611.                         cur += sprintf(cur, "</u>");

  612.                     if(lineattr[x + i] & CACA_ITALICS)

  613.                         cur += sprintf(cur, "</i>");

  614.                     if(lineattr[x + i] & CACA_BOLD)

  615.                         cur += sprintf(cur, "</b>");

  616. 

  617.                     if(needfont)

  618.                         cur += sprintf(cur, "</font>");

  619.                 }

  620.             }

  621. 

  622.             cur += sprintf(cur, "</tt>");

  623.             cur += sprintf(cur, "</td>");

  624.         }

  625.         cur += sprintf(cur, "</tr>\n");

  626.     }

  627. 

  628.     /* Footer */

  629.     cur += sprintf(cur, "</table>\n");

  630. 

  631.     /* Free working memory */

  632.     if (cell_boundary_bitmap)

  633.         free((void *) cell_boundary_bitmap);

  634. 

  635.     /* Crop to really used size */

  636.     debug("html3 export: alloc %lu bytes, realloc %lu",

  637.           (unsigned long int)*bytes, (unsigned long int)(cur - data));

  638.     *bytes = (uintptr_t)(cur - data);

  639.     data = realloc(data, *bytes);

  640. 

  641.     return data;

  642. }

  643. 

  644. static void *export_bbfr(caca_canvas_t const *cv, size_t *bytes)

  645. {

  646.     char *data, *cur;

  647.     int x, y, len;

  648. 

  649.     /* The font markup: less than 100 bytes

  650.      * A line: 1 char for "\n"

  651.      * A glyph: 22 chars for "[f=#xxxxxx][c=#xxxxxx]"

  652.      *          up to 21 chars for "[g][i][s][/s][/i][/g]"

  653.      *          up to 6 chars for the UTF-8 glyph

  654.      *          8 chars for "[/c][/f]" */

  655.     *bytes = 100 + cv->height * (1 + cv->width * (22 + 21 + 6 + 8));

  656.     cur = data = malloc(*bytes);

  657. 

  658.     /* Table */

  659.     cur += sprintf(cur, "[font=Courier New]");

  660. 

  661.     for(y = 0; y < cv->height; y++)

  662.     {

  663.         uint32_t *lineattr = cv->attrs + y * cv->width;

  664.         uint32_t *linechar = cv->chars + y * cv->width;

  665. 

  666.         for(x = 0; x < cv->width; x += len)

  667.         {

  668.             int i, needback, needfront;

  669. 

  670.             /* Use colspan option to factor cells with same attributes

  671.              * (see below) */

  672.             len = 1;

  673.             if(linechar[x] == ' ')

  674.                 while(x + len < cv->width && lineattr[x + len] == lineattr[x]

  675.                         && linechar[x] == ' ')

  676.                     len++;

  677.             else

  678.                 while(x + len < cv->width && lineattr[x + len] == lineattr[x]

  679.                         && linechar[x] != ' ')

  680.                     len++;

  681. 

  682.             needback = caca_attr_to_ansi_bg(lineattr[x]) < 0x10;

  683.             needfront = caca_attr_to_ansi_fg(lineattr[x]) < 0x10;

  684. 

  685.             if(needback)

  686.                 cur += sprintf(cur, "[f=#%.06lx]", (unsigned long int)

  687.                                _caca_attr_to_rgb24bg(lineattr[x]));

  688. 

  689.             if(linechar[x] == ' ')

  690.                 cur += sprintf(cur, "[c=#%.06lx]", (unsigned long int)

  691.                                _caca_attr_to_rgb24bg(lineattr[x]));

  692.             else if(needfront)

  693.                 cur += sprintf(cur, "[c=#%.06lx]", (unsigned long int)

  694.                                _caca_attr_to_rgb24fg(lineattr[x]));

  695. 

  696.             if(lineattr[x] & CACA_BOLD)

  697.                 cur += sprintf(cur, "[g]");

  698.             if(lineattr[x] & CACA_ITALICS)

  699.                 cur += sprintf(cur, "[i]");

  700.             if(lineattr[x] & CACA_UNDERLINE)

  701.                 cur += sprintf(cur, "[s]");

  702.             if(lineattr[x] & CACA_BLINK)

  703.                 ; /* FIXME */

  704. 

  705.             for(i = 0; i < len; i++)

  706.             {

  707.                 if(linechar[x + i] == CACA_MAGIC_FULLWIDTH)

  708.                     ;

  709.                 else if(linechar[x + i] == ' ')

  710.                     *cur++ = '_';

  711.                 else

  712.                     cur += caca_utf32_to_utf8(cur, linechar[x + i]);

  713.             }

  714. 

  715.             if(lineattr[x] & CACA_BLINK)

  716.                 ; /* FIXME */

  717.             if(lineattr[x] & CACA_UNDERLINE)

  718.                 cur += sprintf(cur, "[/s]");

  719.             if(lineattr[x] & CACA_ITALICS)

  720.                 cur += sprintf(cur, "[/i]");

  721.             if(lineattr[x] & CACA_BOLD)

  722.                 cur += sprintf(cur, "[/g]");

  723. 

  724.             if(linechar[x] == ' ' || needfront)

  725.                 cur += sprintf(cur, "[/c]");

  726.             if(needback)

  727.                 cur += sprintf(cur, "[/f]");

  728.         }

  729.         cur += sprintf(cur, "\n");

  730.     }

  731. 

  732.     /* Footer */

  733.     cur += sprintf(cur, "[/font]\n");

  734. 

  735.     /* Crop to really used size */

  736.     debug("bbfr export: alloc %lu bytes, realloc %lu",

  737.           (unsigned long int)*bytes, (unsigned long int)(cur - data));

  738.     *bytes = (uintptr_t)(cur - data);

  739.     data = realloc(data, *bytes);

  740. 

  741.     return data;

  742. }

  743. 

  744. /* Export a PostScript document. */

  745. static void *export_ps(caca_canvas_t const *cv, size_t *bytes)

  746. {

  747.     static char const *ps_header =

  748.         "%!\n"

  749.         "%% libcaca PDF export\n"

  750.         "%%LanguageLevel: 2\n"

  751.         "%%Pages: 1\n"

  752.         "%%DocumentData: Clean7Bit\n"

  753.         "/csquare {\n"

  754.         "  newpath\n"

  755.         "  0 0 moveto\n"

  756.         "  0 1 rlineto\n"

  757.         "  1 0 rlineto\n"

  758.         "  0 -1 rlineto\n"

  759.         "  closepath\n"

  760.         "  setrgbcolor\n"

  761.         "  fill\n"

  762.         "} def\n"

  763.         "/S {\n"

  764.         "  Show\n"

  765.         "} bind def\n"

  766.         "/Courier-Bold findfont\n"

  767.         "8 scalefont\n"

  768.         "setfont\n"

  769.         "gsave\n"

  770.         "6 10 scale\n";

  771. 

  772.     char *data, *cur;

  773.     int x, y;

  774. 

  775.     /* 200 is arbitrary but should be ok */

  776.     *bytes = strlen(ps_header) + 100 + cv->height * (32 + cv->width * 200);

  777.     cur = data = malloc(*bytes);

  778. 

  779.     /* Header */

  780.     cur += sprintf(cur, "%s", ps_header);

  781.     cur += sprintf(cur, "0 %d translate\n", cv->height);

  782. 

  783.     /* Background, drawn using csquare macro defined in header */

  784.     for(y = cv->height; y--; )

  785.     {

  786.         uint32_t *lineattr = cv->attrs + y * cv->width;

  787. 

  788.         for(x = 0; x < cv->width; x++)

  789.         {

  790.             uint8_t argb[8];

  791.             caca_attr_to_argb64(*lineattr++, argb);

  792.             cur += sprintf(cur, "1 0 translate\n %f %f %f csquare\n",

  793.                            (float)argb[1] * (1.0 / 0xf),

  794.                            (float)argb[2] * (1.0 / 0xf),

  795.                            (float)argb[3] * (1.0 / 0xf));

  796.         }

  797. 

  798.         /* Return to beginning of the line, and jump to the next one */

  799.         cur += sprintf(cur, "-%d 1 translate\n", cv->width);

  800.     }

  801. 

  802.     cur += sprintf(cur, "grestore\n"); /* Restore transformation matrix */

  803.     cur += sprintf(cur, "0 %d translate\n", cv->height*10);

  804. 

  805.     for(y = cv->height; y--; )

  806.     {

  807.         uint32_t *lineattr = cv->attrs + (cv->height - y - 1) * cv->width;

  808.         uint32_t *linechar = cv->chars + (cv->height - y - 1) * cv->width;

  809. 

  810.         for(x = 0; x < cv->width; x++)

  811.         {

  812.             uint8_t argb[8];

  813.             uint32_t ch = *linechar++;

  814. 

  815.             caca_attr_to_argb64(*lineattr++, argb);

  816. 

  817.             cur += sprintf(cur, "newpath\n");

  818.             cur += sprintf(cur, "%d %d moveto\n", (x + 1) * 6, y * 10 + 2);

  819.             cur += sprintf(cur, "%f %f %f setrgbcolor\n",

  820.                            (float)argb[5] * (1.0 / 0xf),

  821.                            (float)argb[6] * (1.0 / 0xf),

  822.                            (float)argb[7] * (1.0 / 0xf));

  823. 

  824.             if(ch < 0x00000020)

  825.                 cur += sprintf(cur, "(?) show\n");

  826.             else if(ch >= 0x00000080)

  827.                 cur += sprintf(cur, "(?) show\n");

  828.             else switch((uint8_t)(ch & 0x7f))

  829.             {

  830.                 case '\\':

  831.                 case '(':

  832.                 case ')':

  833.                     cur += sprintf(cur, "(\\%c) show\n", (uint8_t)ch);

  834.                     break;

  835.                 default:

  836.                     cur += sprintf(cur, "(%c) show\n", (uint8_t)ch);

  837.                     break;

  838.             }

  839.         }

  840.     }

  841. 

  842.     cur += sprintf(cur, "showpage\n");

  843. 

  844.     /* Crop to really used size */

  845.     debug("PS export: alloc %lu bytes, realloc %lu",

  846.           (unsigned long int)*bytes, (unsigned long int)(cur - data));

  847.     *bytes = (uintptr_t)(cur - data);

  848.     data = realloc(data, *bytes);

  849. 

  850.     return data;

  851. }

  852. 

  853. /* Export an SVG vector image */

  854. static void *export_svg(caca_canvas_t const *cv, size_t *bytes)

  855. {

  856.     static char const svg_header[] =

  857.         "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

  858.         "<svg width=\"%d\" height=\"%d\" viewBox=\"0 0 %d %d\""

  859.         " xmlns=\"http://www.w3.org/2000/svg\""

  860.         " xmlns:xlink=\"http://www.w3.org/1999/xlink\""

  861.         " xml:space=\"preserve\" version=\"1.1\"  baseProfile=\"full\">\n";

  862. 

  863.     char *data, *cur;

  864.     int x, y;

  865. 

  866.     /* Use 200 as a safety value for character information size

  867.      *

  868.      * Worst case for background, 68 chars:

  869.      *   <rect style="fill:#fff" x="65535" y="65535" width="6" height="10"/>\n

  870.      * Worst case for foreground, 97 chars:

  871.      *   <text style="fill:#fff" font-weight="bold" font-style="italic" x="65535" y="65535">xxxxxx</text>\n

  872.      */

  873.     *bytes = strlen(svg_header) + 128 + cv->width * cv->height * 200;

  874.     cur = data = malloc(*bytes);

  875. 

  876.     /* Header */

  877.     cur += sprintf(cur, svg_header, cv->width * 6, cv->height * 10,

  878.                                     cv->width * 6, cv->height * 10);

  879. 

  880.     cur += sprintf(cur, " <g id=\"mainlayer\" font-size=\"10\""

  881.                         " style=\"font-family: monospace\">\n");

  882. 

  883.     /* Background */

  884.     for(y = 0; y < cv->height; y++)

  885.     {

  886.         uint32_t *lineattr = cv->attrs + y * cv->width;

  887. 

  888.         for(x = 0; x < cv->width; x++)

  889.         {

  890.             cur += sprintf(cur, "<rect style=\"fill:#%.03x\" x=\"%d\" y=\"%d\""

  891.                                 " width=\"6\" height=\"10\"/>\n",

  892.                                 caca_attr_to_rgb12_bg(*lineattr++),

  893.                                 x * 6, y * 10);

  894.         }

  895.     }

  896. 

  897.     /* Text */

  898.     for(y = 0; y < cv->height; y++)

  899.     {

  900.         uint32_t *lineattr = cv->attrs + y * cv->width;

  901.         uint32_t *linechar = cv->chars + y * cv->width;

  902. 

  903.         for(x = 0; x < cv->width; x++)

  904.         {

  905.             uint32_t ch = *linechar++;

  906. 

  907.             if(ch == ' ' || ch == CACA_MAGIC_FULLWIDTH)

  908.             {

  909.                 lineattr++;

  910.                 continue;

  911.             }

  912. 

  913.             cur += sprintf(cur, "<text style=\"fill:#%.03x\"%s%s "

  914.                                 "x=\"%d\" y=\"%d\">",

  915.                                 caca_attr_to_rgb12_fg(*lineattr),

  916.                                 (*lineattr & CACA_BOLD) ? " font-weight=\"bold\"" : "",

  917.                                 (*lineattr & CACA_ITALICS) ? " font-style=\"italic\"" : "",

  918.                                 x * 6, (y * 10) + 8);

  919.             lineattr++;

  920. 

  921.             if(ch < 0x00000020)

  922.                 *cur++ = '?';

  923.             else if(ch > 0x0000007f)

  924.                 cur += caca_utf32_to_utf8(cur, ch);

  925.             else switch((uint8_t)ch)

  926.             {

  927.                 case '>': cur += sprintf(cur, "&gt;"); break;

  928.                 case '<': cur += sprintf(cur, "&lt;"); break;

  929.                 case '&': cur += sprintf(cur, "&amp;"); break;

  930.                 default: *cur++ = (uint8_t)ch; break;

  931.             }

  932.             cur += sprintf(cur, "</text>\n");

  933.         }

  934.     }

  935. 

  936.     cur += sprintf(cur, " </g>\n");

  937.     cur += sprintf(cur, "</svg>\n");

  938. 

  939.     /* Crop to really used size */

  940.     debug("SVG export: alloc %lu bytes, realloc %lu",

  941.           (unsigned long int)*bytes, (unsigned long int)(cur - data));

  942.     *bytes = (uintptr_t)(cur - data);

  943.     data = realloc(data, *bytes);

  944. 

  945.     return data;

  946. }

  947. 

  948. /* Export a TGA image */

  949. static void *export_tga(caca_canvas_t const *cv, size_t *bytes)

  950. {

  951.     char const * const *fontlist;

  952.     char *data, *cur;

  953.     caca_font_t *f;

  954.     int i, w, h;

  955. 

  956.     fontlist = caca_get_font_list();

  957.     if(!fontlist[0])

  958.     {

  959.         seterrno(EINVAL);

  960.         return NULL;

  961.     }

  962. 

  963.     f = caca_load_font(fontlist[0], 0);

  964. 

  965.     w = caca_get_canvas_width(cv) * caca_get_font_width(f);

  966.     h = caca_get_canvas_height(cv) * caca_get_font_height(f);

  967. 

  968.     *bytes = w * h * 4 + 18; /* 32 bpp + 18 bytes for the header */

  969.     cur = data = malloc(*bytes);

  970. 

  971.     /* ID Length */

  972.     cur += write_u8(cur, 0);

  973.     /* Color Map Type: no colormap */

  974.     cur += write_u8(cur, 0);

  975.     /* Image Type: uncompressed truecolor */

  976.     cur += write_u8(cur, 2);

  977.     /* Color Map Specification: no color map */

  978.     memset(cur, 0, 5); cur += 5;

  979. 

  980.     /* Image Specification */

  981.     cur += sprintf(cur, "%c%c", 0, 0); /* X Origin */

  982.     cur += sprintf(cur, "%c%c", 0, 0); /* Y Origin */

  983.     cur += sprintf(cur, "%c%c", w & 0xff, w >> 8); /* Width */

  984.     cur += sprintf(cur, "%c%c", h & 0xff, h >> 8); /* Height */

  985.     cur += write_u8(cur, 32); /* Pixel Depth */

  986.     cur += write_u8(cur, 40); /* Image Descriptor */

  987. 

  988.     /* Image ID: no ID */

  989.     /* Color Map Data: no colormap */

  990. 

  991.     /* Image Data */

  992.     caca_render_canvas(cv, f, cur, w, h, 4 * w);

  993. 

  994.     /* Swap bytes. What a waste of time. */

  995.     for(i = 0; i < w * h * 4; i += 4)

  996.     {

  997.         char c;

  998.         c = cur[i]; cur[i] = cur[i + 3]; cur[i + 3] = c;

  999.         c = cur[i + 1]; cur[i + 1] = cur[i + 2]; cur[i + 2] = c;

  1000.     }

  1001. 

  1002.     caca_free_font(f);

  1003. 

  1004.     return data;

  1005. }

  1006. 

  1007. /* Generate troff representation of current canvas. */

  1008. static void *export_troff(caca_canvas_t const *cv, size_t *bytes)

  1009. {

  1010.     char *data, *cur;

  1011.     int x, y;

  1012. 

  1013.     uint32_t prevfg = 0;

  1014.     uint32_t prevbg = 0;

  1015.     int started = 0;

  1016. 

  1017.     /* Each char is at most

  1018.      *  2x\mM (2x10)

  1019.      *  + \fB + \fI + \fR (9)

  1020.      *  + 4 bytes = 33

  1021.      * Each line has a \n (1) and maybe 0xc2 0xa0 (2)

  1022.      * Header has .nf\n (3)

  1023.      */

  1024.     *bytes = 3 + cv->height * 3 + (cv->width * cv->height * 33);

  1025.     cur = data = malloc(*bytes);

  1026. 

  1027.     cur += write_string(cur, ".nf\n");

  1028. 

  1029.     prevfg = 0;

  1030.     prevbg = 0;

  1031.     started = 0;

  1032. 

  1033.     for(y = 0; y < cv->height; y++)

  1034.     {

  1035.         uint32_t *lineattr = cv->attrs + y * cv->width;

  1036.         uint32_t *linechar = cv->chars + y * cv->width;

  1037. 

  1038.         for(x = 0; x < cv->width; x++)

  1039.         {

  1040.             static char const * ansi2troff[16] =

  1041.             {

  1042.                 /* Dark */

  1043.                 "black", "blue", "green", "cyan",

  1044.                 "red", "magenta", "yellow", "white",

  1045.                 /* Bright */

  1046.                 "black", "blue", "green", "cyan",

  1047.                 "red", "magenta", "yellow", "white",

  1048.             };

  1049.             uint8_t fg = caca_attr_to_ansi_fg(lineattr[x]);

  1050.             uint8_t bg = caca_attr_to_ansi_bg(lineattr[x]);

  1051.             uint32_t ch = linechar[x];

  1052. 

  1053.             if(fg != prevfg || !started)

  1054.                 cur += sprintf(cur, "\\m[%s]", ansi2troff[fg]);

  1055.             if(bg != prevbg || !started)

  1056.                 cur += sprintf(cur, "\\M[%s]", ansi2troff[bg]);

  1057.             if(lineattr[x] & CACA_BOLD)

  1058.                 cur += sprintf(cur, "\\fB");

  1059.             if(lineattr[x] & CACA_ITALICS)

  1060.                 cur += sprintf(cur, "\\fI");

  1061. 

  1062.             if(ch == '\\')

  1063.                 cur += sprintf(cur, "\\\\");

  1064.             else if(ch == ' ')

  1065.             {

  1066.                 /* Use unbreakable space at line ends, else spaces are dropped */

  1067.                 if(x == 0 || x == cv->width-1)

  1068.                     cur += sprintf(cur, "%c%c", 0xc2, 0xa0);

  1069.                 else

  1070.                     cur += caca_utf32_to_utf8(cur, ch);

  1071.             }

  1072.             else

  1073.                 cur += caca_utf32_to_utf8(cur, ch);

  1074. 

  1075.             if(lineattr[x] & (CACA_BOLD|CACA_ITALICS))

  1076.                 cur += sprintf(cur, "\\fR");

  1077. 

  1078.             prevfg = fg;

  1079.             prevbg = bg;

  1080.             started = 1;

  1081.         }

  1082.         cur += write_u8(cur, '\n');

  1083.     }

  1084.     /* Crop to really used size */

  1085.     debug("troff export: alloc %lu bytes, realloc %lu",

  1086.           (unsigned long int)*bytes, (unsigned long int)(cur - data));

  1087.     *bytes = (uintptr_t)(cur - data);

  1088.     data = realloc(data, *bytes);

  1089. 

  1090.     return data;

  1091. }

  1092. 

  1093. /*

  1094.  * XXX: The following functions are aliases.

  1095.  */

  1096. 

  1097. void *caca_export_memory(caca_canvas_t const *, char const *,

  1098.                          size_t *) CACA_ALIAS(caca_export_canvas_to_memory);