cacalabs
/
libcaca
mirror of https://github.com/cacalabs/libcaca.git
1
0
Fork 0
Code Issues 0 Releases 7 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1605 Commits
1 Branch
5.9 MiB
 
 
 
 
 
 
Tree: fb7c744402
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fb7c744402'
${ noResults }
libcaca/caca/codec/export.c

1214 lines
40 KiB
Raw Blame History 

  1. /*

  2.  *  libcaca       Colour ASCII-Art library

  3.  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>

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

  5.  *                All Rights Reserved

  6.  *

  7.  *  $Id$

  8.  *

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

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

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

  12.  *  To Public License, Version 2, as published by Sam Hocevar. See

  13.  *  http://sam.zoy.org/wtfpl/COPYING for more details.

  14.  */

  15. 

  16. /*

  17.  *  This file contains various export functions

  18.  */

  19. 

  20. #include "config.h"

  21. 

  22. #if !defined(__KERNEL__)

  23. #   include <stdlib.h>

  24. #   include <stdio.h>

  25. #   include <string.h>

  26. #endif

  27. 

  28. #include "caca.h"

  29. #include "caca_internals.h"

  30. 

  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. static inline int sprintu16(char *s, uint16_t x)

  41. {

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

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

  44.     return 2;

  45. }

  46. 

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

  48. static void *export_ansi(caca_canvas_t const *, size_t *);

  49. static void *export_utf8(caca_canvas_t const *, size_t *, int);

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

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

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

  53. static void *export_irc(caca_canvas_t const *, size_t *);

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

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

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

  57. 

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

  59.  *

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

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

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

  63.  *

  64.  *  Valid values for \c format are:

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

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

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

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

  69.  *    most navigators, including textmode ones.

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

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

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

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

  74.  *

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

  76.  *  - \c EINVAL Unsupported format requested.

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

  78.  *

  79.  *  \param cv A libcaca canvas

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

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

  82.  *         will be written.

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

  84.  */

  85. void *caca_export_memory(caca_canvas_t const *cv, char const *format,

  86.                           size_t *bytes)

  87. {

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

  89.         return export_caca(cv, bytes);

  90. 

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

  92.         return export_ansi(cv, bytes);

  93. 

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

  95.         return export_utf8(cv, bytes, 0);

  96. 

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

  98.         return export_utf8(cv, bytes, 1);

  99. 

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

  101.         return export_html(cv, bytes);

  102. 

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

  104.         return export_html3(cv, bytes);

  105. 

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

  107.         return export_bbfr(cv, bytes);

  108. 

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

  110.         return export_irc(cv, bytes);

  111. 

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

  113.         return export_ps(cv, bytes);

  114. 

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

  116.         return export_svg(cv, bytes);

  117. 

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

  119.         return export_tga(cv, bytes);

  120. 

  121.     seterrno(EINVAL);

  122.     return NULL;

  123. }

  124. 

  125. /** \brief Get available export formats

  126.  *

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

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

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

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

  131.  *

  132.  *  This function never fails.

  133.  *

  134.  *  \return An array of strings.

  135.  */

  136. char const * const * caca_get_export_list(void)

  137. {

  138.     static char const * const list[] =

  139.     {

  140.         "caca", "native libcaca format",

  141.         "ansi", "ANSI",

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

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

  144.         "html", "HTML",

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

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

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

  148.         "ps", "PostScript document",

  149.         "svg", "SVG vector image",

  150.         "tga", "TGA image",

  151.         NULL, NULL

  152.     };

  153. 

  154.     return list;

  155. }

  156. 

  157. /*

  158.  * XXX: the following functions are local.

  159.  */

  160. 

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

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

  163. {

  164.     char *data, *cur;

  165.     int f, n;

  166. 

  167.     /* 52 bytes for the header:

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

  169.      *  - 16 bytes for the canvas header

  170.      *  - 32 bytes for the frame info

  171.      * 8 bytes for each character cell */

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

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

  174. 

  175.     /* magic */

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

  177. 

  178.     /* canvas_header */

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

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

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

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

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

  184. 

  185.     /* frame_info */

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

  187.     {

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

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

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

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

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

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

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

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

  196.     }

  197. 

  198.     /* canvas_data */

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

  200.     {

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

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

  203. 

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

  205.         {

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

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

  208.         }

  209.     }

  210. 

  211.     return data;

  212. }

  213. 

  214. /* Generate UTF-8 representation of current canvas. */

  215. static void *export_utf8(caca_canvas_t const *cv, size_t *bytes,

  216.                          int cr)

  217. {

  218.     static uint8_t const palette[] =

  219.     {

  220.         0,  4,  2,  6, 1,  5,  3,  7,

  221.         8, 12, 10, 14, 9, 13, 11, 15

  222.     };

  223. 

  224.     char *data, *cur;

  225.     int x, y;

  226. 

  227.     /* 23 bytes assumed for max length per pixel ('\e[5;1;3x;4y;9x;10ym' plus

  228.      * 4 max bytes for a UTF-8 character).

  229.      * Add height*9 to that (zeroes color at the end and jump to next line) */

  230.     *bytes = (cv->height * 9) + (cv->width * cv->height * 23);

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

  232. 

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

  234.     {

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

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

  237. 

  238.         uint8_t prevfg = 0x10;

  239.         uint8_t prevbg = 0x10;

  240. 

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

  242.         {

  243.             uint32_t attr = lineattr[x];

  244.             uint32_t ch = linechar[x];

  245.             uint8_t ansifg, ansibg, fg, bg;

  246. 

  247.             if(ch == CACA_MAGIC_FULLWIDTH)

  248.                 continue;

  249. 

  250.             ansifg = caca_attr_to_ansi_fg(attr);

  251.             ansibg = caca_attr_to_ansi_bg(attr);

  252. 

  253.             fg = ansifg < 0x10 ? palette[ansifg] : 0x10;

  254.             bg = ansibg < 0x10 ? palette[ansibg] : 0x10;

  255. 

  256.             /* TODO: the [0 could be omitted in some cases */

  257.             if(fg != prevfg || bg != prevbg)

  258.             {

  259.                 cur += sprintf(cur, "\033[0");

  260. 

  261.                 if(fg < 8)

  262.                     cur += sprintf(cur, ";3%d", fg);

  263.                 else if(fg < 16)

  264.                     cur += sprintf(cur, ";1;3%d;9%d", fg - 8, fg - 8);

  265. 

  266.                 if(bg < 8)

  267.                     cur += sprintf(cur, ";4%d", bg);

  268.                 else if(bg < 16)

  269.                     cur += sprintf(cur, ";5;4%d;10%d", bg - 8, bg - 8);

  270. 

  271.                 cur += sprintf(cur, "m");

  272.             }

  273. 

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

  275. 

  276.             prevfg = fg;

  277.             prevbg = bg;

  278.         }

  279. 

  280.         if(prevfg != 0x10 || prevbg != 0x10)

  281.             cur += sprintf(cur, "\033[0m");

  282. 

  283.         cur += sprintf(cur, cr ? "\r\n" : "\n");

  284.     }

  285. 

  286.     /* Crop to really used size */

  287.     debug("utf8 export: alloc %lu bytes, realloc %lu",

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

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

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

  291. 

  292.     return data;

  293. }

  294. 

  295. /* Generate ANSI representation of current canvas. */

  296. static void *export_ansi(caca_canvas_t const *cv, size_t *bytes)

  297. {

  298.     static uint8_t const palette[] =

  299.     {

  300.         0,  4,  2,  6, 1,  5,  3,  7,

  301.         8, 12, 10, 14, 9, 13, 11, 15

  302.     };

  303. 

  304.     char *data, *cur;

  305.     int x, y;

  306. 

  307.     uint8_t prevfg = -1;

  308.     uint8_t prevbg = -1;

  309. 

  310.     /* 16 bytes assumed for max length per pixel ('\e[5;1;3x;4ym' plus

  311.      * 1 byte for a CP437 character).

  312.      * Add height*9 to that (zeroes color at the end and jump to next line) */

  313.     *bytes = (cv->height * 9) + (cv->width * cv->height * 16);

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

  315. 

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

  317.     {

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

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

  320. 

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

  322.         {

  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;

  327.             uint32_t ch = linechar[x];

  328. 

  329.             if(ch == CACA_MAGIC_FULLWIDTH)

  330.                 ch = '?';

  331. 

  332.             if(fg != prevfg || bg != prevbg)

  333.             {

  334.                 cur += sprintf(cur, "\033[0;");

  335. 

  336.                 if(fg < 8)

  337.                     if(bg < 8)

  338.                         cur += sprintf(cur, "3%d;4%dm", fg, bg);

  339.                     else

  340.                         cur += sprintf(cur, "5;3%d;4%dm", fg, bg - 8);

  341.                 else

  342.                     if(bg < 8)

  343.                         cur += sprintf(cur, "1;3%d;4%dm", fg - 8, bg);

  344.                     else

  345.                         cur += sprintf(cur, "5;1;3%d;4%dm", fg - 8, bg - 8);

  346.             }

  347. 

  348.             *cur++ = caca_utf32_to_cp437(ch);

  349. 

  350.             prevfg = fg;

  351.             prevbg = bg;

  352.         }

  353. 

  354.         if(cv->width == 80)

  355.         {

  356.             cur += sprintf(cur, "\033[s\n\033[u");

  357.         }

  358.         else

  359.         {

  360.             cur += sprintf(cur, "\033[0m\r\n");

  361.             prevfg = -1;

  362.             prevbg = -1;

  363.         }

  364.     }

  365. 

  366.     /* Crop to really used size */

  367.     debug("ansi export: alloc %lu bytes, realloc %lu",

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

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

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

  371. 

  372.     return data;

  373. }

  374. 

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

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

  377. {

  378.     char *data, *cur;

  379.     int x, y, len;

  380. 

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

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

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

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

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

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

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

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

  389. 

  390.     /* HTML header */

  391. 

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

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

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

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

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

  397.                         caca_get_version());

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

  399. 

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

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

  402. 

  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 = 0; x < cv->width; x += len)

  409.         {

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

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

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

  413.                                caca_attr_to_rgb12_fg(lineattr[x]));

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

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

  416.                                caca_attr_to_rgb12_bg(lineattr[x]));

  417.             if(lineattr[x] & CACA_BOLD)

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

  419.             if(lineattr[x] & CACA_ITALICS)

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

  421.             if(lineattr[x] & CACA_UNDERLINE)

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

  423.             if(lineattr[x] & CACA_BLINK)

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

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

  426. 

  427.             for(len = 0;

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

  429.                 len++)

  430.             {

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

  432.                     ;

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

  434.                         ||

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

  436.                          &&

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

  438.                 {

  439.                     /* Control characters and space converted to

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

  441.                      * but we use the equivalent numeric character

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

  443.                      * XHTML with no DTD too. */

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

  445.                 }

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

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

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

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

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

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

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

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

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

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

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

  457.                     cur += sprintf(cur, "%c", (uint8_t)linechar[x + len]);

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

  459.                         &&

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

  461.                         &&

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

  463.                          ||

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

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

  466.                 else

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

  468.                      * REPLACEMENT CHARACTER */

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

  470.             }

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

  472.         }

  473.         /* New line */

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

  475.     }

  476. 

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

  478. 

  479.     /* Crop to really used size */

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

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

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

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

  484. 

  485.     return data;

  486. }

  487. 

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

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

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

  491.  * correct header. */

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

  493. {

  494.     char *data, *cur;

  495.     int x, y, len;

  496.     int has_multi_cell_row = 0;

  497.     unsigned char *cell_boundary_bitmap;

  498. 

  499.     /* Table */

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

  501.     if(cell_boundary_bitmap)

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

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

  504.     {

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

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

  507. 

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

  509.             if((! (cell_boundary_bitmap

  510.                    ?

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

  512.                    :

  513.                    has_multi_cell_row))

  514.                &&

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

  516.                  &&

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

  518.                 ||

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

  520.                  !=

  521.                  caca_attr_to_ansi_bg(lineattr[x]))

  522.                 ||

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

  524.                  ?

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

  526.                   !=

  527.                   _caca_attr_to_rgb24bg(lineattr[x]))

  528.                  :

  529.                  0)))

  530.             {

  531.                 has_multi_cell_row = 1;

  532.                 if(cell_boundary_bitmap)

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

  534.             }

  535.     }

  536.     

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

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

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

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

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

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

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

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

  545. 

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

  547. 

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

  549.     {

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

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

  552. 

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

  554. 

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

  556.         {

  557.             int i, needfont = 0;

  558.             int nonblank = 0;

  559. 

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

  561.              * (see below) */

  562.             len = 1;

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

  564.                   &&

  565.                   ((y

  566.                     &&

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

  568.                     &&

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

  570.                      ||

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

  572.                    ||

  573.                    (! (cell_boundary_bitmap

  574.                        ?

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

  576.                        :

  577.                        has_multi_cell_row))

  578.                    ||

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

  580.                    ||

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

  582.                   &&

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

  584.                    ||

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

  586.                   &&

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

  588.                    ==

  589.                    caca_attr_to_ansi_bg(lineattr[x]))

  590.                   &&

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

  592.                    ?

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

  594.                     ==

  595.                     _caca_attr_to_rgb24bg(lineattr[x]))

  596.                    :

  597.                    1))

  598.                 len++;

  599. 

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

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

  602.                       ||

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

  604.                        &&

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

  606.                     nonblank = 1;

  607. 

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

  609. 

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

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

  612.                                _caca_attr_to_rgb24bg(lineattr[x]));

  613. 

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

  615.             {

  616.                 int colspan;

  617. 

  618.                 colspan = len;

  619.                 if(cell_boundary_bitmap)

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

  621.                         if(i

  622.                            &&

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

  624.                               &

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

  626.                             colspan --;

  627.                 if(colspan > 1)

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

  629.             }

  630. 

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

  632. 

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

  634. 

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

  636.             {

  637.                 if(nonblank

  638.                    &&

  639.                    ((! i)

  640.                     ||

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

  642.                 {

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

  644.                                 !=

  645.                                 CACA_DEFAULT);

  646. 

  647.                     if(needfont)

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

  649.                                        (unsigned long int)

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

  651. 

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

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

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

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

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

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

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

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

  660.                 }

  661. 

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

  663.                     ;

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

  665.                         ||

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

  667.                          &&

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

  669.                 {

  670.                     /* Control characters and space converted to

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

  672.                      * but we use the equivalent numeric character

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

  674.                      * XHTML with no DTD too. */

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

  676.                 }

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

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

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

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

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

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

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

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

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

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

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

  688.                     cur += sprintf(cur, "%c", (uint8_t)linechar[x + i]);

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

  690.                         &&

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

  692.                         &&

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

  694.                          ||

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

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

  697.                 else

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

  699.                      * REPLACEMENT CHARACTER */

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

  701. 

  702.                 if (nonblank

  703.                     &&

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

  705.                      ||

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

  707.                 {

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

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

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

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

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

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

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

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

  716. 

  717.                     if(needfont)

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

  719.                 }

  720.             }

  721. 

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

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

  724.         }

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

  726.     }

  727. 

  728.     /* Footer */

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

  730. 

  731.     /* Free working memory */

  732.     if (cell_boundary_bitmap)

  733.         free((void *) cell_boundary_bitmap);

  734. 

  735.     /* Crop to really used size */

  736.     debug("html3 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. static void *export_bbfr(caca_canvas_t const *cv, size_t *bytes)

  745. {

  746.     char *data, *cur;

  747.     int x, y, len;

  748. 

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

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

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

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

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

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

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

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

  757. 

  758.     /* Table */

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

  760. 

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

  762.     {

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

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

  765. 

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

  767.         {

  768.             int i, needback, needfront;

  769. 

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

  771.              * (see below) */

  772.             len = 1;

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

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

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

  776.                     len++;

  777.             else

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

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

  780.                     len++;

  781. 

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

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

  784. 

  785.             if(needback)

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

  787.                                _caca_attr_to_rgb24bg(lineattr[x]));

  788. 

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

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

  791.                                _caca_attr_to_rgb24bg(lineattr[x]));

  792.             else if(needfront)

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

  794.                                _caca_attr_to_rgb24fg(lineattr[x]));

  795. 

  796.             if(lineattr[x] & CACA_BOLD)

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

  798.             if(lineattr[x] & CACA_ITALICS)

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

  800.             if(lineattr[x] & CACA_UNDERLINE)

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

  802.             if(lineattr[x] & CACA_BLINK)

  803.                 ; /* FIXME */

  804. 

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

  806.             {

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

  808.                     ;

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

  810.                     *cur++ = '_';

  811.                 else

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

  813.             }

  814. 

  815.             if(lineattr[x] & CACA_BLINK)

  816.                 ; /* FIXME */

  817.             if(lineattr[x] & CACA_UNDERLINE)

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

  819.             if(lineattr[x] & CACA_ITALICS)

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

  821.             if(lineattr[x] & CACA_BOLD)

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

  823. 

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

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

  826.             if(needback)

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

  828.         }

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

  830.     }

  831. 

  832.     /* Footer */

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

  834. 

  835.     /* Crop to really used size */

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

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

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

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

  840. 

  841.     return data;

  842. }

  843. 

  844. /* Export a text file with IRC colours */

  845. static void *export_irc(caca_canvas_t const *cv, size_t *bytes)

  846. {

  847.     static uint8_t const palette[] =

  848.     {

  849.         1, 2, 3, 10, 5, 6, 7, 15, /* Dark */

  850.         14, 12, 9, 11, 4, 13, 8, 0, /* Light */

  851.     };

  852. 

  853.     char *data, *cur;

  854.     int x, y;

  855. 

  856.     /* 14 bytes assumed for max length per pixel. Worst case scenario:

  857.      * ^Cxx,yy   6 bytes

  858.      * ^B^B      2 bytes

  859.      * ch        6 bytes

  860.      * 3 bytes for max length per line. Worst case scenario:

  861.      * <spc>     1 byte (for empty lines)

  862.      * \r\n      2 bytes

  863.      * In real life, the average bytes per pixel value will be around 5.

  864.      */

  865. 

  866.     *bytes = 2 + cv->height * (3 + cv->width * 14);

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

  868. 

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

  870.     {

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

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

  873. 

  874.         uint8_t prevfg = 0x10;

  875.         uint8_t prevbg = 0x10;

  876. 

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

  878.         {

  879.             uint32_t attr = lineattr[x];

  880.             uint32_t ch = linechar[x];

  881.             uint8_t ansifg, ansibg, fg, bg;

  882. 

  883.             if(ch == CACA_MAGIC_FULLWIDTH)

  884.                 continue;

  885. 

  886.             ansifg = caca_attr_to_ansi_fg(attr);

  887.             ansibg = caca_attr_to_ansi_bg(attr);

  888. 

  889.             fg = ansifg < 0x10 ? palette[ansifg] : 0x10;

  890.             bg = ansibg < 0x10 ? palette[ansibg] : 0x10;

  891. 

  892.             /* TODO: optimise series of same fg / same bg

  893.              *       don't change fg value if ch == ' '

  894.              *       make sure the \x03,%d trick works everywhere */

  895.             if(bg != prevbg || fg != prevfg)

  896.             {

  897.                 int need_escape = 0;

  898. 

  899.                 if(bg == 0x10)

  900.                 {

  901.                     if(fg == 0x10)

  902.                         cur += sprintf(cur, "\x0f");

  903.                     else

  904.                     {

  905.                         if(prevbg == 0x10)

  906.                             cur += sprintf(cur, "\x03%d", fg);

  907.                         else

  908.                             cur += sprintf(cur, "\x0f\x03%d", fg);

  909. 

  910.                         if(ch == (uint32_t)',')

  911.                             need_escape = 1;

  912.                     }

  913.                 }

  914.                 else

  915.                 {

  916.                     if(fg == 0x10)

  917.                         cur += sprintf(cur, "\x0f\x03,%d", bg);

  918.                     else

  919.                         cur += sprintf(cur, "\x03%d,%d", fg, bg);

  920.                 }

  921. 

  922.                 if(ch >= (uint32_t)'0' && ch <= (uint32_t)'9')

  923.                     need_escape = 1;

  924. 

  925.                 if(need_escape)

  926.                     cur += sprintf(cur, "\x02\x02");

  927.             }

  928. 

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

  930.             prevfg = fg;

  931.             prevbg = bg;

  932.         }

  933. 

  934.         /* TODO: do the same the day we optimise whole lines above */

  935.         if(!cv->width)

  936.             *cur++ = ' ';

  937. 

  938.         *cur++ = '\r';

  939.         *cur++ = '\n';

  940.     }

  941. 

  942.     /* Crop to really used size */

  943.     debug("IRC export: alloc %lu bytes, realloc %lu",

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

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

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

  947. 

  948.     return data;

  949. }

  950. 

  951. /* Export a PostScript document. */

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

  953. {

  954.     static char const *ps_header =

  955.         "%!\n"

  956.         "%% libcaca PDF export\n"

  957.         "%%LanguageLevel: 2\n"

  958.         "%%Pages: 1\n"

  959.         "%%DocumentData: Clean7Bit\n"

  960.         "/csquare {\n"

  961.         "  newpath\n"

  962.         "  0 0 moveto\n"

  963.         "  0 1 rlineto\n"

  964.         "  1 0 rlineto\n"

  965.         "  0 -1 rlineto\n"

  966.         "  closepath\n"

  967.         "  setrgbcolor\n"

  968.         "  fill\n"

  969.         "} def\n"

  970.         "/S {\n"

  971.         "  Show\n"

  972.         "} bind def\n"

  973.         "/Courier-Bold findfont\n"

  974.         "8 scalefont\n"

  975.         "setfont\n"

  976.         "gsave\n"

  977.         "6 10 scale\n";

  978. 

  979.     char *data, *cur;

  980.     int x, y;

  981. 

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

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

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

  985. 

  986.     /* Header */

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

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

  989. 

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

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

  992.     {

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

  994. 

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

  996.         {

  997.             uint8_t argb[8];

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

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

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

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

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

  1003.         }

  1004. 

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

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

  1007.     }

  1008. 

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

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

  1011. 

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

  1013.     {

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

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

  1016. 

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

  1018.         {

  1019.             uint8_t argb[8];

  1020.             uint32_t ch = *linechar++;

  1021. 

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

  1023. 

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

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

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

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

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

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

  1030. 

  1031.             if(ch < 0x00000020)

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

  1033.             else if(ch >= 0x00000080)

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

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

  1036.             {

  1037.                 case '\\':

  1038.                 case '(':

  1039.                 case ')':

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

  1041.                     break;

  1042.                 default:

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

  1044.                     break;

  1045.             }

  1046.         }

  1047.     }

  1048. 

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

  1050. 

  1051.     /* Crop to really used size */

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

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

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

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

  1056. 

  1057.     return data;

  1058. }

  1059. 

  1060. /* Export an SVG vector image */

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

  1062. {

  1063.     static char const svg_header[] =

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

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

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

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

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

  1069. 

  1070.     char *data, *cur;

  1071.     int x, y;

  1072. 

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

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

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

  1076. 

  1077.     /* Header */

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

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

  1080. 

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

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

  1083. 

  1084.     /* Background */

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

  1086.     {

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

  1088. 

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

  1090.         {

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

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

  1093.                                 caca_attr_to_rgb12_bg(*lineattr++),

  1094.                                 x * 6, y * 10);

  1095.         }

  1096.     }

  1097. 

  1098.     /* Text */

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

  1100.     {

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

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

  1103. 

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

  1105.         {

  1106.             uint32_t ch = *linechar++;

  1107. 

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

  1109.             {

  1110.                 lineattr++;

  1111.                 continue;

  1112.             }

  1113. 

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

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

  1116.                                 caca_attr_to_rgb12_fg(*lineattr++),

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

  1118. 

  1119.             if(ch < 0x00000020)

  1120.                 *cur++ = '?';

  1121.             else if(ch > 0x0000007f)

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

  1123.             else switch((uint8_t)ch)

  1124.             {

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

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

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

  1128.                 default: *cur++ = ch; break;

  1129.             }

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

  1131.         }

  1132.     }

  1133. 

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

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

  1136. 

  1137.     /* Crop to really used size */

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

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

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

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

  1142. 

  1143.     return data;

  1144. }

  1145. 

  1146. /* Export a TGA image */

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

  1148. {

  1149.     char const * const *fontlist;

  1150.     char *data, *cur;

  1151.     caca_font_t *f;

  1152.     int i, w, h;

  1153. 

  1154.     fontlist = caca_get_font_list();

  1155.     if(!fontlist[0])

  1156.     {

  1157.         seterrno(EINVAL);

  1158.         return NULL;

  1159.     }

  1160. 

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

  1162. 

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

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

  1165. 

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

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

  1168. 

  1169.     /* ID Length */

  1170.     cur += sprintf(cur, "%c", 0);

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

  1172.     cur += sprintf(cur, "%c", 0);

  1173.     /* Image Type: uncompressed truecolor */

  1174.     cur += sprintf(cur, "%c", 2);

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

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

  1177. 

  1178.     /* Image Specification */

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

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

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

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

  1183.     cur += sprintf(cur, "%c", 32); /* Pixel Depth */

  1184.     cur += sprintf(cur, "%c", 40); /* Image Descriptor */

  1185. 

  1186.     /* Image ID: no ID */

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

  1188. 

  1189.     /* Image Data */

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

  1191. 

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

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

  1194.     {

  1195.         char c;

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

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

  1198.     }

  1199. 

  1200.     caca_free_font(f);

  1201. 

  1202.     return data;

  1203. }

  1204. 

  1205. /*

  1206.  * XXX: The following functions are aliases.

  1207.  */

  1208. 

  1209. void *cucul_export_memory(cucul_canvas_t const *, char const *,

  1210.                           size_t *) CACA_ALIAS(caca_export_memory);

  1211. char const * const * cucul_get_export_list(void)

  1212.          CACA_ALIAS(caca_get_export_list);