source: libcaca/trunk/caca/codec/export.c @ 3491

Last change on this file since 3491 was 3491, checked in by Pascal Terjan, 11 years ago

Revert r3478

  • Property svn:keywords set to Id
File size: 39.7 KB
Line 
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: export.c 3491 2009-05-20 14:44:47Z pterjan $
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
31static 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
40static 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
47static void *export_caca(caca_canvas_t const *, size_t *);
48static void *export_ansi(caca_canvas_t const *, size_t *);
49static void *export_utf8(caca_canvas_t const *, size_t *, int);
50static void *export_html(caca_canvas_t const *, size_t *);
51static void *export_html3(caca_canvas_t const *, size_t *);
52static void *export_bbfr(caca_canvas_t const *, size_t *);
53static void *export_irc(caca_canvas_t const *, size_t *);
54static void *export_ps(caca_canvas_t const *, size_t *);
55static void *export_svg(caca_canvas_t const *, size_t *);
56static void *export_tga(caca_canvas_t const *, size_t *);
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 */
85void *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 */
136char 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. */
162static 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. */
215static 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. */
296static 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. */
376static 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. */
492static 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
744static 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 */
845static 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. */
952static 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 */
1061static 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++ = (uint8_t)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 */
1147static 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
1209void *cucul_export_memory(cucul_canvas_t const *, char const *,
1210                          size_t *) CACA_ALIAS(caca_export_memory);
1211char const * const * cucul_get_export_list(void)
1212         CACA_ALIAS(caca_get_export_list);
1213
Note: See TracBrowser for help on using the repository browser.