source: libcaca/trunk/cucul/export.c @ 925

Last change on this file since 925 was 925, checked in by Sam Hocevar, 14 years ago
  • Added "utf8" export that is like ANSI but exports UTF-8 encoded coloured text.
  • Property svn:keywords set to Id
File size: 24.9 KB
Line 
1/*
2 *  libcucul      Canvas for ultrafast compositing of Unicode letters
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 925 2006-05-04 22:00:52Z sam $
8 *
9 *  This library is free software; you can redistribute it and/or
10 *  modify it under the terms of the Do What The Fuck You Want To
11 *  Public License, Version 2, as published by Sam Hocevar. See
12 *  http://sam.zoy.org/wtfpl/COPYING for more details.
13 */
14
15/*
16 *  This file contains various export functions
17 */
18
19#include "config.h"
20#include "common.h"
21
22#if !defined(__KERNEL__)
23#   if defined(HAVE_ERRNO_H)
24#       include <errno.h>
25#   endif
26#   include <stdlib.h>
27#   include <stdio.h>
28#   include <string.h>
29#endif
30
31#include "cucul.h"
32#include "cucul_internals.h"
33
34static void export_caca(cucul_canvas_t *, cucul_buffer_t *);
35static void export_ansi(cucul_canvas_t *, cucul_buffer_t *);
36static void export_utf8(cucul_canvas_t *, cucul_buffer_t *);
37static void export_html(cucul_canvas_t *, cucul_buffer_t *);
38static void export_html3(cucul_canvas_t *, cucul_buffer_t *);
39static void export_irc(cucul_canvas_t *, cucul_buffer_t *);
40static void export_ps(cucul_canvas_t *, cucul_buffer_t *);
41static void export_svg(cucul_canvas_t *, cucul_buffer_t *);
42static void export_tga(cucul_canvas_t *, cucul_buffer_t *);
43
44/** \brief Export a canvas into a foreign format.
45 *
46 *  This function exports a libcucul canvas into various foreign formats such
47 *  as ANSI art, HTML, IRC colours, etc. One should use cucul_get_buffer_data()
48 *  and cucul_get_buffer_size() to access the buffer contents. The allocated
49 *  data is valid until cucul_free_buffer() is called.
50 *
51 *  Valid values for \c format are:
52 *
53 *  \li \c "caca": export native libcaca files.
54 *
55 *  \li \c "ansi": export ANSI art (CP437 charset with ANSI colour codes).
56 *
57 *  \li \c "html": export an HTML page with CSS information.
58 *
59 *  \li \c "html3": export an HTML table that should be compatible with
60 *      most navigators, including textmode ones.
61 *
62 *  \li \c "irc": export UTF-8 text with mIRC colour codes.
63 *
64 *  \li \c "ps": export a PostScript document.
65 *
66 *  \li \c "svg": export an SVG vector image.
67 *
68 *  \li \c "tga": export a TGA image.
69 *
70 *  If an error occurs, NULL is returned and \b errno is set accordingly:
71 *  - \c EINVAL Invalid format requested.
72 *  - \c ENOMEM Not enough memory to allocate output buffer.
73 *
74 *  \param cv A libcucul canvas
75 *  \param format A string describing the requested output format.
76 *  \return A libcucul buffer, or NULL in case of error.
77 */
78cucul_buffer_t * cucul_export_canvas(cucul_canvas_t *cv, char const *format)
79{
80    cucul_buffer_t *ex;
81
82    ex = malloc(sizeof(cucul_buffer_t));
83    if(!ex)
84    {
85#if defined(HAVE_ERRNO_H)
86        errno = ENOMEM;
87#endif
88        return NULL;
89    }
90
91    ex->size = 0;
92    ex->data = NULL;
93    ex->user_data = 0;
94
95    if(!strcasecmp("caca", format))
96        export_caca(cv, ex);
97    else if(!strcasecmp("ansi", format))
98        export_ansi(cv, ex);
99    else if(!strcasecmp("utf8", format))
100        export_utf8(cv, ex);
101    else if(!strcasecmp("html", format))
102        export_html(cv, ex);
103    else if(!strcasecmp("html3", format))
104        export_html3(cv, ex);
105    else if(!strcasecmp("irc", format))
106        export_irc(cv, ex);
107    else if(!strcasecmp("ps", format))
108        export_ps(cv, ex);
109    else if(!strcasecmp("svg", format))
110        export_svg(cv, ex);
111    else if(!strcasecmp("tga", format))
112        export_tga(cv, ex);
113
114    if(ex->size == 0)
115    {
116        free(ex);
117#if defined(HAVE_ERRNO_H)
118        errno = EINVAL;
119#endif
120        return NULL;
121    }
122
123    return ex;
124}
125
126/** \brief Get available export formats
127 *
128 *  Return a list of available export formats. The list is a NULL-terminated
129 *  array of strings, interleaving a string containing the internal value for
130 *  the export format, to be used with cucul_export_canvas(), and a string
131 *  containing the natural language description for that export format.
132 *
133 *  This function never fails.
134 *
135 *  \return An array of strings.
136 */
137char const * const * cucul_get_export_list(void)
138{
139    static char const * const list[] =
140    {
141        "caca", "native libcaca format",
142        "ansi", "ANSI",
143        "utf8", "UTF-8 with ANSI escape codes",
144        "html", "HTML",
145        "html3", "backwards-compatible HTML",
146        "irc", "IRC with mIRC colours",
147        "ps", "PostScript document",
148        "svg", "SVG vector image",
149        "tga", "TGA image",
150        NULL, NULL
151    };
152
153    return list;
154}
155
156/*
157 * XXX: the following functions are local.
158 */
159
160/* Generate a native libcaca canvas file. */
161static void export_caca(cucul_canvas_t *cv, cucul_buffer_t *ex)
162{
163    uint32_t *attr = cv->attr;
164    uint32_t *chars = cv->chars;
165    char *cur;
166    uint32_t w, h;
167    unsigned int n;
168
169    /* 16 bytes for the canvas, 8 bytes for each character cell. */
170    ex->size = 16 + 8 * cv->width * cv->height;
171    ex->data = malloc(ex->size);
172
173    cur = ex->data;
174
175    w = cv->width;
176    h = cv->height;
177
178    cur += sprintf(cur, "CACACANV%c%c%c%c%c%c%c%c",
179                   (w >> 24), (w >> 16) & 0xff, (w >> 8) & 0xff, w & 0xff,
180                   (h >> 24), (h >> 16) & 0xff, (h >> 8) & 0xff, h & 0xff);
181
182    for(n = cv->height * cv->width; n--; )
183    {
184        uint32_t ch = *chars++;
185        uint32_t a = *attr++;
186
187        *cur++ = ch >> 24;
188        *cur++ = (ch >> 16) & 0xff;
189        *cur++ = (ch >> 8) & 0xff;
190        *cur++ = ch & 0xff;
191
192        *cur++ = a >> 24;
193        *cur++ = (a >> 16) & 0xff;
194        *cur++ = (a >> 8) & 0xff;
195        *cur++ = a & 0xff;
196    }
197}
198
199/* Generate UTF-8 representation of current canvas. */
200static void export_utf8(cucul_canvas_t *cv, cucul_buffer_t *ex)
201{
202    static uint8_t const palette[] =
203    {
204        0,  4,  2,  6, 1,  5,  3,  7,
205        8, 12, 10, 14, 9, 13, 11, 15
206    };
207
208    char *cur;
209    unsigned int x, y;
210
211    /* 23 bytes assumed for max length per pixel ('\e[5;1;3x;4y;9x;10ym' plus
212     * 4 max bytes for a UTF-8 character).
213     * Add height*9 to that (zeroes color at the end and jump to next line) */
214    ex->size = (cv->height * 9) + (cv->width * cv->height * 23);
215    ex->data = malloc(ex->size);
216
217    cur = ex->data;
218
219    for(y = 0; y < cv->height; y++)
220    {
221        uint32_t *lineattr = cv->attr + y * cv->width;
222        uint32_t *linechar = cv->chars + y * cv->width;
223
224        uint8_t prevfg = -1;
225        uint8_t prevbg = -1;
226
227        for(x = 0; x < cv->width; x++)
228        {
229            static const uint8_t mark[7] =
230            {
231                0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
232            };
233
234            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
235            uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
236            uint32_t ch = linechar[x];
237
238            if(fg != prevfg || bg != prevbg)
239            {
240                cur += sprintf(cur, "\033[0;");
241
242                if(fg < 8)
243                    if(bg < 8)
244                        cur += sprintf(cur, "3%d;4%dm", fg, bg);
245                    else
246                        cur += sprintf(cur, "5;3%d;4%d;10%dm",
247                                            fg, bg - 8, bg - 8);
248                else
249                    if(bg < 8)
250                        cur += sprintf(cur, "1;3%d;4%d;9%dm",
251                                            fg - 8, bg, fg - 8);
252                    else
253                        cur += sprintf(cur, "5;1;3%d;4%d;9%d;10%dm",
254                                            fg - 8, bg - 8, fg - 8, bg - 8);
255            }
256
257            if(ch < 0x80)
258            {
259                *cur++ = (ch >= 0x20) ? ch : '?';
260            }
261            else
262            {
263                int bytes = (ch < 0x800) ? 2 : (ch < 0x10000) ? 3 : 4;
264                char *parser;
265
266                cur += bytes;
267                parser = cur;
268
269                switch(bytes)
270                {
271                    case 4: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
272                    case 3: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
273                    case 2: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
274                }
275                *--parser = ch | mark[bytes];
276            }
277
278            prevfg = fg;
279            prevbg = bg;
280        }
281
282        cur += sprintf(cur, "\033[0m\r\n");
283    }
284
285    /* Crop to really used size */
286    ex->size = (uintptr_t)(cur - ex->data);
287    ex->data = realloc(ex->data, ex->size);
288}
289
290/* Generate ANSI representation of current canvas. */
291static void export_ansi(cucul_canvas_t *cv, cucul_buffer_t *ex)
292{
293    static uint8_t const palette[] =
294    {
295        0,  4,  2,  6, 1,  5,  3,  7,
296        8, 12, 10, 14, 9, 13, 11, 15
297    };
298
299    char *cur;
300    unsigned int x, y;
301
302    /* 23 bytes assumed for max length per pixel ('\e[5;1;3x;4y;9x;10ym' plus
303     * 4 max bytes for a UTF-8 character).
304     * Add height*9 to that (zeroes color at the end and jump to next line) */
305    ex->size = (cv->height * 9) + (cv->width * cv->height * 23);
306    ex->data = malloc(ex->size);
307
308    cur = ex->data;
309
310    for(y = 0; y < cv->height; y++)
311    {
312        uint32_t *lineattr = cv->attr + y * cv->width;
313        uint32_t *linechar = cv->chars + y * cv->width;
314
315        uint8_t prevfg = -1;
316        uint8_t prevbg = -1;
317
318        for(x = 0; x < cv->width; x++)
319        {
320            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
321            uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
322            uint32_t ch = linechar[x];
323
324            if(fg != prevfg || bg != prevbg)
325            {
326                cur += sprintf(cur, "\033[0;");
327
328                if(fg < 8)
329                    if(bg < 8)
330                        cur += sprintf(cur, "3%d;4%dm", fg, bg);
331                    else
332                        cur += sprintf(cur, "5;3%d;4%d;10%dm",
333                                            fg, bg - 8, bg - 8);
334                else
335                    if(bg < 8)
336                        cur += sprintf(cur, "1;3%d;4%d;9%dm",
337                                            fg - 8, bg, fg - 8);
338                    else
339                        cur += sprintf(cur, "5;1;3%d;4%d;9%d;10%dm",
340                                            fg - 8, bg - 8, fg - 8, bg - 8);
341            }
342
343            *cur++ = (ch >= 0x20 && ch < 0x7f) ? ch : '?';
344
345            prevfg = fg;
346            prevbg = bg;
347        }
348
349        cur += sprintf(cur, "\033[0m\r\n");
350    }
351
352    /* Crop to really used size */
353    ex->size = (uintptr_t)(cur - ex->data);
354    ex->data = realloc(ex->data, ex->size);
355}
356
357/* Generate HTML representation of current canvas. */
358static void export_html(cucul_canvas_t *cv, cucul_buffer_t *ex)
359{
360    char *cur;
361    unsigned int x, y, len;
362
363    /* The HTML header: less than 1000 bytes
364     * A line: 7 chars for "<br />\n"
365     * A glyph: 47 chars for "<span style="color:#xxx;background-color:#xxx">"
366     *          up to 9 chars for "&#xxxxxx;", far less for pure ASCII
367     *          7 chars for "</span>" */
368    ex->size = 1000 + cv->height * (7 + cv->width * (47 + 9 + 7));
369    ex->data = malloc(ex->size);
370
371    cur = ex->data;
372
373    /* HTML header */
374    cur += sprintf(cur, "<html><head>\n");
375    cur += sprintf(cur, "<title>Generated by libcaca %s</title>\n", VERSION);
376    cur += sprintf(cur, "</head><body>\n");
377
378    cur += sprintf(cur, "<div cellpadding='0' cellspacing='0' style='%s'>\n",
379                        "font-family: monospace, fixed; font-weight: bold;");
380
381    for(y = 0; y < cv->height; y++)
382    {
383        uint32_t *lineattr = cv->attr + y * cv->width;
384        uint32_t *linechar = cv->chars + y * cv->width;
385
386        for(x = 0; x < cv->width; x += len)
387        {
388            cur += sprintf(cur, "<span style=\"color:#%.03x;"
389                                "background-color:#%.03x\">",
390                                _cucul_argb32_to_rgb12fg(lineattr[x]),
391                                _cucul_argb32_to_rgb12bg(lineattr[x]));
392
393            for(len = 0;
394                x + len < cv->width && lineattr[x + len] == lineattr[x];
395                len++)
396            {
397                if(linechar[x + len] <= 0x00000020)
398                    cur += sprintf(cur, "&nbsp;");
399                else if(linechar[x + len] < 0x00000080)
400                    cur += sprintf(cur, "%c", linechar[x + len]);
401                else
402                    cur += sprintf(cur, "&#%i;", linechar[x + len]);
403            }
404            cur += sprintf(cur, "</span>");
405        }
406        /* New line */
407        cur += sprintf(cur, "<br />\n");
408    }
409
410    cur += sprintf(cur, "</div></body></html>\n");
411
412    /* Crop to really used size */
413    ex->size = strlen(ex->data) + 1;
414    ex->data = realloc(ex->data, ex->size);
415}
416
417/* Export an HTML3 document. This function is way bigger than export_html(),
418 * but permits viewing in old browsers (or limited ones such as links). It
419 * will not work under gecko (mozilla rendering engine) unless you set a
420 * correct header. */
421static void export_html3(cucul_canvas_t *cv, cucul_buffer_t *ex)
422{
423    char *cur;
424    unsigned int x, y, len;
425
426    /* The HTML table markup: less than 1000 bytes
427     * A line: 10 chars for "<tr></tr>\n"
428     * A glyph: 40 chars for "<td bgcolor=#xxxxxx><font color=#xxxxxx>"
429     *          up to 9 chars for "&#xxxxxx;", far less for pure ASCII
430     *          12 chars for "</font></td>" */
431    ex->size = 1000 + cv->height * (10 + cv->width * (40 + 9 + 12));
432    ex->data = malloc(ex->size);
433
434    cur = ex->data;
435
436    /* Table */
437    cur += sprintf(cur, "<table cols='%d' cellpadding='0' cellspacing='0'>\n",
438                        cv->height);
439
440    for(y = 0; y < cv->height; y++)
441    {
442        uint32_t *lineattr = cv->attr + y * cv->width;
443        uint32_t *linechar = cv->chars + y * cv->width;
444
445        cur += sprintf(cur, "<tr>");
446
447        for(x = 0; x < cv->width; x += len)
448        {
449            unsigned int i;
450
451            /* Use colspan option to factor cells with same attributes
452             * (see below) */
453            len = 1;
454            while(x + len < cv->width && lineattr[x + len] == lineattr[x])
455                len++;
456
457            cur += sprintf(cur, "<td bgcolor=#%.06x",
458                           _cucul_argb32_to_rgb24bg(lineattr[x]));
459
460            if(len > 1)
461                cur += sprintf(cur, " colspan=%d", len);
462
463            cur += sprintf(cur, "><font color=#%.06x>",
464                           _cucul_argb32_to_rgb24fg(lineattr[x]));
465
466            for(i = 0; i < len; i++)
467            {
468                if(linechar[x + i] <= 0x00000020)
469                    cur += sprintf(cur, "&nbsp;");
470                else if(linechar[x + i] < 0x00000080)
471                    cur += sprintf(cur, "%c", linechar[x + i]);
472                else
473                    cur += sprintf(cur, "&#%i;", linechar[x + i]);
474            }
475
476            cur += sprintf(cur, "</font></td>");
477        }
478        cur += sprintf(cur, "</tr>\n");
479    }
480
481    /* Footer */
482    cur += sprintf(cur, "</table>\n");
483
484    /* Crop to really used size */
485    ex->size = (uintptr_t)(cur - ex->data);
486    ex->data = realloc(ex->data, ex->size);
487}
488
489/* Export a text file with IRC colours */
490static void export_irc(cucul_canvas_t *cv, cucul_buffer_t *ex)
491{
492    static uint8_t const palette[] =
493    {
494        1, 2, 3, 10, 5, 6, 7, 15, /* Dark */
495        14, 12, 9, 11, 4, 13, 8, 0, /* Light */
496    };
497
498    char *cur;
499    unsigned int x, y;
500
501    /* 11 bytes assumed for max length per pixel. Worst case scenario:
502     * ^Cxx,yy   6 bytes
503     * ^B^B      2 bytes
504     * ch        1 byte
505     * \r\n      2 bytes
506     * In real life, the average bytes per pixel value will be around 5.
507     */
508
509    ex->size = 2 + (cv->width * cv->height * 11);
510    ex->data = malloc(ex->size);
511
512    cur = ex->data;
513
514    for(y = 0; y < cv->height; y++)
515    {
516        uint32_t *lineattr = cv->attr + y * cv->width;
517        uint32_t *linechar = cv->chars + y * cv->width;
518
519        uint8_t prevfg = -1;
520        uint8_t prevbg = -1;
521
522        for(x = 0; x < cv->width; x++)
523        {
524            uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
525            uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
526            uint32_t ch = linechar[x];
527
528#if 0
529            if(bg == prevbg)
530            {
531                if(fg == prevfg)
532                    ; /* Same fg/bg, do nothing */
533                else if(ch == (uint32_t)' ')
534                    fg = prevfg; /* Hackety hack */
535                else
536                {
537                    cur += sprintf(cur, "\x03%d", fg);
538                    if(ch >= (uint32_t)'0' && ch <= (uint32_t)'9')
539                        cur += sprintf(cur, "\x02\x02");
540                }
541            }
542            else
543            {
544                if(fg == prevfg)
545                    cur += sprintf(cur, "\x03,%d", bg);
546                else
547                    cur += sprintf(cur, "\x03%d,%d", fg, bg);
548
549                if(ch >= (uint32_t)'0' && ch <= (uint32_t)'9')
550                    cur += sprintf(cur, "\x02\x02");
551            }
552#else
553            if(bg != prevbg || fg != prevfg)
554            {
555                cur += sprintf(cur, "\x03%d,%d", fg, bg);
556                if(ch >= (uint32_t)'0' && ch <= (uint32_t)'9')
557                    cur += sprintf(cur, "\x02\x02");
558            }
559#endif
560            *cur++ = ch & 0x7f;
561            prevfg = fg;
562            prevbg = bg;
563        }
564        *cur++ = '\r';
565        *cur++ = '\n';
566    }
567
568    /* Crop to really used size */
569    ex->size = (uintptr_t)(cur - ex->data);
570    ex->data = realloc(ex->data, ex->size);
571}
572
573/* Export a PostScript document. */
574static void export_ps(cucul_canvas_t *cv, cucul_buffer_t *ex)
575{
576    static char const *ps_header =
577        "%!\n"
578        "%% libcaca PDF export\n"
579        "%%LanguageLevel: 2\n"
580        "%%Pages: 1\n"
581        "%%DocumentData: Clean7Bit\n"
582        "/csquare {\n"
583        "  newpath\n"
584        "  0 0 moveto\n"
585        "  0 1 rlineto\n"
586        "  1 0 rlineto\n"
587        "  0 -1 rlineto\n"
588        "  closepath\n"
589        "  setrgbcolor\n"
590        "  fill\n"
591        "} def\n"
592        "/S {\n"
593        "  Show\n"
594        "} bind def\n"
595        "/Courier-Bold findfont\n"
596        "8 scalefont\n"
597        "setfont\n"
598        "gsave\n"
599        "6 10 scale\n";
600
601    char *cur;
602    unsigned int x, y;
603
604    /* 200 is arbitrary but should be ok */
605    ex->size = strlen(ps_header) + (cv->width * cv->height * 200);
606    ex->data = malloc(ex->size);
607
608    cur = ex->data;
609
610    /* Header */
611    cur += sprintf(cur, "%s", ps_header);
612
613    /* Background, drawn using csquare macro defined in header */
614    for(y = cv->height; y--; )
615    {
616        uint32_t *lineattr = cv->attr + y * cv->width;
617
618        for(x = 0; x < cv->width; x++)
619        {
620            uint8_t argb[8];
621            _cucul_argb32_to_argb4(*lineattr++, argb);
622            cur += sprintf(cur, "1 0 translate\n %f %f %f csquare\n",
623                           (float)argb[1] * (1.0 / 0xf),
624                           (float)argb[2] * (1.0 / 0xf),
625                           (float)argb[3] * (1.0 / 0xf));
626        }
627
628        /* Return to beginning of the line, and jump to the next one */
629        cur += sprintf(cur, "-%d 1 translate\n", cv->width);
630    }
631
632    cur += sprintf(cur, "grestore\n"); /* Restore transformation matrix */
633
634    for(y = cv->height; y--; )
635    {
636        uint32_t *lineattr = cv->attr + (cv->height - y - 1) * cv->width;
637        uint32_t *linechar = cv->chars + (cv->height - y - 1) * cv->width;
638
639        for(x = 0; x < cv->width; x++)
640        {
641            uint8_t argb[8];
642            uint32_t ch = *linechar++;
643
644            _cucul_argb32_to_argb4(*lineattr++, argb);
645
646            cur += sprintf(cur, "newpath\n");
647            cur += sprintf(cur, "%d %d moveto\n", (x + 1) * 6, y * 10 + 2);
648            cur += sprintf(cur, "%f %f %f setrgbcolor\n",
649                           (float)argb[5] * (1.0 / 0xf),
650                           (float)argb[6] * (1.0 / 0xf),
651                           (float)argb[7] * (1.0 / 0xf));
652
653            if(ch < 0x00000020)
654                cur += sprintf(cur, "(?) show\n");
655            else if(ch >= 0x00000080)
656                cur += sprintf(cur, "(?) show\n");
657            else switch((uint8_t)(ch & 0x7f))
658            {
659                case '\\':
660                case '(':
661                case ')':
662                    cur += sprintf(cur, "(\\%c) show\n", ch);
663                    break;
664                default:
665                    cur += sprintf(cur, "(%c) show\n", ch);
666                    break;
667            }
668        }
669    }
670
671    cur += sprintf(cur, "showpage\n");
672
673    /* Crop to really used size */
674    ex->size = (uintptr_t)(cur - ex->data);
675    ex->data = realloc(ex->data, ex->size);
676}
677
678/* Export an SVG vector image */
679static void export_svg(cucul_canvas_t *cv, cucul_buffer_t *ex)
680{
681    static char const svg_header[] =
682        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
683        "<svg width=\"%d\" height=\"%d\" viewBox=\"0 0 %d %d\""
684        " xmlns=\"http://www.w3.org/2000/svg\""
685        " xmlns:xlink=\"http://www.w3.org/1999/xlink\""
686        " xml:space=\"preserve\" version=\"1.1\"  baseProfile=\"full\">\n";
687
688    char *cur;
689    unsigned int x, y;
690
691    /* 200 is arbitrary but should be ok */
692    ex->size = strlen(svg_header) + (cv->width * cv->height * 200);
693    ex->data = malloc(ex->size);
694
695    cur = ex->data;
696
697    /* Header */
698    cur += sprintf(cur, svg_header, cv->width * 6, cv->height * 10,
699                                    cv->width * 6, cv->height * 10);
700
701    cur += sprintf(cur, " <g id=\"mainlayer\" font-size=\"12\">\n");
702
703    /* Background */
704    for(y = 0; y < cv->height; y++)
705    {
706        uint32_t *lineattr = cv->attr + y * cv->width;
707
708        for(x = 0; x < cv->width; x++)
709        {
710            cur += sprintf(cur, "<rect style=\"fill:#%.03x\" x=\"%d\" y=\"%d\""
711                                " width=\"6\" height=\"10\"/>\n",
712                                _cucul_argb32_to_rgb12bg(*lineattr++),
713                                x * 6, y * 10);
714        }
715    }
716
717    /* Text */
718    for(y = 0; y < cv->height; y++)
719    {
720        uint32_t *lineattr = cv->attr + y * cv->width;
721        uint32_t *linechar = cv->chars + y * cv->width;
722
723        for(x = 0; x < cv->width; x++)
724        {
725            uint32_t ch = *linechar++;
726
727            cur += sprintf(cur, "<text style=\"fill:#%.03x\" "
728                                "x=\"%d\" y=\"%d\">",
729                                _cucul_argb32_to_rgb12fg(*lineattr++),
730                                x * 6, (y * 10) + 10);
731            if(ch < 0x00000020)
732                cur += sprintf(cur, "?");
733            else if(ch > 0x0000007f)
734            {
735                static const uint8_t mark[7] =
736                {
737                    0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
738                };
739
740                char buf[10], *parser;
741                int bytes = (ch < 0x800) ? 2 : (ch < 0x10000) ? 3 : 4;
742
743                buf[bytes] = '\0';
744                parser = buf + bytes;
745
746                switch(bytes)
747                {
748                    case 4: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
749                    case 3: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
750                    case 2: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
751                }
752                *--parser = ch | mark[bytes];
753
754                cur += sprintf(cur, "%s", buf);
755            }
756            else switch((uint8_t)ch)
757            {
758                case '>': cur += sprintf(cur, "&gt;"); break;
759                case '<': cur += sprintf(cur, "&lt;"); break;
760                case '&': cur += sprintf(cur, "&amp;"); break;
761                default: cur += sprintf(cur, "%c", ch); break;
762            }
763            cur += sprintf(cur, "</text>\n");
764        }
765    }
766
767    cur += sprintf(cur, " </g>\n");
768    cur += sprintf(cur, "</svg>\n");
769
770    /* Crop to really used size */
771    ex->size = (uintptr_t)(cur - ex->data);
772    ex->data = realloc(ex->data, ex->size);
773}
774
775/* Export a TGA image */
776static void export_tga(cucul_canvas_t *cv, cucul_buffer_t *ex)
777{
778    char const * const * fontlist;
779    char * cur;
780    cucul_font_t *f;
781    unsigned int i, w, h;
782
783    fontlist = cucul_get_font_list();
784    if(!fontlist[0])
785        return;
786
787    f = cucul_load_font(fontlist[0], 0);
788
789    w = cucul_get_canvas_width(cv) * cucul_get_font_width(f);
790    h = cucul_get_canvas_height(cv) * cucul_get_font_height(f);
791
792    ex->size = w * h * 4 + 18; /* 32 bpp + 18 bytes for the header */
793    ex->data = malloc(ex->size);
794
795    cur = ex->data;
796
797    /* ID Length */
798    cur += sprintf(cur, "%c", 0);
799    /* Color Map Type: no colormap */
800    cur += sprintf(cur, "%c", 0);
801    /* Image Type: uncompressed truecolor */
802    cur += sprintf(cur, "%c", 2);
803    /* Color Map Specification: no color map */
804    memset(cur, 0, 5); cur += 5;
805
806    /* Image Specification */
807    cur += sprintf(cur, "%c%c", 0, 0); /* X Origin */
808    cur += sprintf(cur, "%c%c", 0, 0); /* Y Origin */
809    cur += sprintf(cur, "%c%c", w & 0xff, w >> 8); /* Width */
810    cur += sprintf(cur, "%c%c", h & 0xff, h >> 8); /* Height */
811    cur += sprintf(cur, "%c", 32); /* Pixel Depth */
812    cur += sprintf(cur, "%c", 40); /* Image Descriptor */
813
814    /* Image ID: no ID */
815    /* Color Map Data: no colormap */
816
817    /* Image Data */
818    cucul_render_canvas(cv, f, cur, w, h, 4 * w);
819
820    /* Swap bytes. What a waste of time. */
821    for(i = 0; i < w * h * 4; i += 4)
822    {
823        char w;
824        w = cur[i]; cur[i] = cur[i + 3]; cur[i + 3] = w;
825        w = cur[i + 1]; cur[i + 1] = cur[i + 2]; cur[i + 2] = w;
826    }
827
828    cucul_free_font(f);
829}
830
Note: See TracBrowser for help on using the repository browser.