source: libcaca/trunk/cucul/import.c @ 901

Last change on this file since 901 was 901, checked in by Jean-Yves Lamoureux, 15 years ago
  • Fixed documentation for import
  • Property svn:keywords set to Id
File size: 12.9 KB
Line 
1/*
2 *  libcucul      Canvas for ultrafast compositing of Unicode letters
3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
4 *                All Rights Reserved
5 *
6 *  $Id: import.c 901 2006-04-26 12:18:35Z jylam $
7 *
8 *  This library is free software; you can redistribute it and/or
9 *  modify it under the terms of the Do What The Fuck You Want To
10 *  Public License, Version 2, as published by Sam Hocevar. See
11 *  http://sam.zoy.org/wtfpl/COPYING for more details.
12 */
13
14/*
15 *  This file contains various import functions.
16 */
17
18#include "config.h"
19#include "common.h"
20
21#if !defined(__KERNEL__)
22#   include <stdio.h>
23#   include <stdlib.h>
24#   include <string.h>
25#endif
26
27#include "cucul.h"
28#include "cucul_internals.h"
29
30static cucul_canvas_t *import_caca(void const *, unsigned int);
31static cucul_canvas_t *import_text(void const *, unsigned int);
32static cucul_canvas_t *import_ansi(void const *, unsigned int);
33
34/** \brief Import a buffer into a canvas
35 *
36 *  This function imports a memory area into an internal libcucul canvas.
37 *
38 *  Valid values for \c format are:
39 *
40 *  \li \c "": attempt to autodetect the file format.
41 *
42 *  \li \c "ansi": import ANSI files.
43 *
44 *  \li \c "caca": import native libcaca files.
45 *
46 *  \param buffer A \e libcucul buffer containing the data to be loaded
47 *         into a canvas.
48 *  \param format A string describing the input format.
49 *  \return A libcucul canvas, or NULL in case of error.
50 */
51cucul_canvas_t * cucul_import_canvas(cucul_buffer_t *buffer, char const *format)
52{
53    char const *buf = (char const*)buffer->data;
54
55    if(buffer->size == 0 || buffer->data == NULL)
56        return NULL;
57
58    if(!strcasecmp("caca", format))
59        return import_caca(buffer->data, buffer->size);
60    if(!strcasecmp("text", format))
61        return import_text(buffer->data, buffer->size);
62    if(!strcasecmp("ansi", format))
63        return import_ansi(buffer->data, buffer->size);
64
65    /* Autodetection */
66    if(!strcasecmp("", format))
67    {
68        unsigned int i=0;
69        /* if 4 first letters are CACA */
70        if(buffer->size >= 4 &&
71            buf[0] == 'C' && buf[1] == 'A' && buf[2] == 'C' && buf[3] != 'A')
72            return import_caca(buffer->data, buffer->size);
73
74        /* If we find ESC[ argv, we guess it's an ANSI file */
75        while(i < buffer->size - 1)
76        {
77            if((buf[i] == 0x1b) && (buf[i+1] == '['))
78                return import_ansi(buffer->data, buffer->size);
79            i++;
80        }
81
82        /* Otherwise, import it as text */
83        return import_text(buffer->data, buffer->size);
84    }
85    return NULL;
86}
87
88/** \brief Get available import formats
89 *
90 *  Return a list of available import formats. The list is a NULL-terminated
91 *  array of strings, interleaving a string containing the internal value for
92 *  the import format, to be used with cucul_import_canvas(), and a string
93 *  containing the natural language description for that import format.
94 *
95 *  \return An array of strings.
96 */
97char const * const * cucul_get_import_list(void)
98{
99    static char const * const list[] =
100    {
101        "", "autodetect",
102        "text", "plain text",
103        "caca", "native libcaca format",
104        "ansi", "ANSI coloured text",
105        NULL, NULL
106    };
107
108    return list;
109}
110
111/*
112 * XXX: the following functions are local.
113 */
114
115static cucul_canvas_t *import_caca(void const *data, unsigned int size)
116{
117    cucul_canvas_t *cv;
118    uint8_t const *buf = (uint8_t const *)data;
119    unsigned int width, height, n;
120
121    if(size < 16)
122        return NULL;
123
124    if(buf[0] != 'C' || buf[1] != 'A' || buf[2] != 'C' || buf[3] != 'A')
125        return NULL;
126
127    if(buf[4] != 'C' || buf[5] != 'A' || buf[6] != 'N' || buf[7] != 'V')
128        return NULL;
129
130    width = ((uint32_t)buf[8] << 24) | ((uint32_t)buf[9] << 16)
131           | ((uint32_t)buf[10] << 8) | (uint32_t)buf[11];
132    height = ((uint32_t)buf[12] << 24) | ((uint32_t)buf[13] << 16)
133            | ((uint32_t)buf[14] << 8) | (uint32_t)buf[15];
134
135    if(!width || !height)
136        return NULL;
137
138    if(size != 16 + width * height * 8)
139        return NULL;
140
141    cv = cucul_create_canvas(width, height);
142
143    if(!cv)
144        return NULL;
145
146    for(n = height * width; n--; )
147    {
148        cv->chars[n] = ((uint32_t)buf[16 + 0 + 8 * n] << 24)
149                     | ((uint32_t)buf[16 + 1 + 8 * n] << 16)
150                     | ((uint32_t)buf[16 + 2 + 8 * n] << 8)
151                     | (uint32_t)buf[16 + 3 + 8 * n];
152        cv->attr[n] = ((uint32_t)buf[16 + 4 + 8 * n] << 24)
153                    | ((uint32_t)buf[16 + 5 + 8 * n] << 16)
154                    | ((uint32_t)buf[16 + 6 + 8 * n] << 8)
155                    | (uint32_t)buf[16 + 7 + 8 * n];
156    }
157
158    return cv;
159}
160
161static cucul_canvas_t *import_text(void const *data, unsigned int size)
162{
163    cucul_canvas_t *cv;
164    char const *text = (char const *)data;
165    unsigned int width = 1, height = 1, x = 0, y = 0, i;
166
167    cv = cucul_create_canvas(width, height);
168    cucul_set_color(cv, CUCUL_COLOR_DEFAULT, CUCUL_COLOR_TRANSPARENT);
169
170    for(i = 0; i < size; i++)
171    {
172        unsigned char ch = *text++;
173
174        if(ch == '\r')
175            continue;
176
177        if(ch == '\n')
178        {
179            x = 0;
180            y++;
181            continue;
182        }
183
184        if(x >= width || y >= height)
185        {
186            if(x >= width)
187                width = x + 1;
188
189            if(y >= height)
190                height = y + 1;
191
192            cucul_set_canvas_size(cv, width, height);
193        }
194
195        cucul_putchar(cv, x, y, ch);
196        x++;
197    }
198
199    return cv;
200}
201
202static void manage_modifiers(int, uint8_t *, uint8_t *, uint8_t *,
203                             uint8_t *, uint8_t *, uint8_t *);
204
205static cucul_canvas_t *import_ansi(void const *data, unsigned int size)
206{
207    cucul_canvas_t *cv;
208    unsigned char const *buffer = (unsigned char const*)data;
209    unsigned int i, j;
210    int x = 0, y = 0;
211    unsigned int width = 80, height = 25;
212    int save_x = 0, save_y = 0;
213    unsigned int skip;
214    uint8_t fg, bg, save_fg, save_bg, bold, reverse;
215
216    fg = save_fg = CUCUL_COLOR_LIGHTGRAY;
217    bg = save_bg = CUCUL_COLOR_BLACK;
218    bold = reverse = 0;
219
220    cv = cucul_create_canvas(width, height);
221    cucul_set_color(cv, fg, bg);
222
223    for(i = 0; i < size; i += skip)
224    {
225        skip = 1;
226
227        if(buffer[i] == '\x1a' && size - i >= 8
228           && !memcmp(buffer + i + 1, "SAUCE00", 7))
229            break; /* End before SAUCE data */
230
231        if(buffer[i] == '\r')
232            continue; /* DOS sucks */
233
234        if(buffer[i] == '\n')
235        {
236            x = 0;
237            y++;
238            continue;
239        }
240
241        /* Interpret escape commands, as per Standard ECMA-48 "Control
242         * Functions for Coded Character Sets", 5.4. Control sequences. */
243        if(buffer[i] == '\x1b' && buffer[i + 1] == '[')
244        {
245            unsigned int argc = 0, argv[101];
246            unsigned int param, inter, final;
247
248        /* Compute offsets to parameter bytes, intermediate bytes and
249         * to the final byte. Only the final byte is mandatory, there
250         * can be zero of the others.
251         *
252         * +-----+------------------+---------------------+-----------------+
253         * | CSI | parameter bytes  | intermediate bytes  |   final byte    |
254         * |     |   0x30 - 0x3f    |    0x20 - 0x2f      |   0x40 - 0x7e   |
255         * | ^[[ | 0123456789:;<=>? | SPC !"#$%&'()*+,-./ | azAZ@[\]^_`{|}~ |
256         * +-----+------------------+---------------------+-----------------+
257         */
258            param = 2;
259
260            for(inter = param; i + inter < size; inter++)
261                if(buffer[i + inter] < 0x30 || buffer[i + inter] > 0x3f)
262                    break;
263
264            for(final = inter; i + final < size; final++)
265                if(buffer[i + final] < 0x20 || buffer[i + final] > 0x2f)
266                    break;
267
268            if(buffer[i + final] < 0x40 || buffer[i + final] > 0x7e)
269                break; /* Invalid Final Byte */
270
271            skip += final;
272
273            /* Sanity checks */
274            if(param < inter && buffer[i + param] >= 0x3c)
275            {
276                //fprintf(stderr, "private sequence \"^[[%.*s\"\n",
277                //                final - param + 1, buffer + i + param);
278                continue; /* Private sequence, skip it entirely */
279            }
280
281            if(final - param > 100)
282                continue; /* Suspiciously long sequence, skip it */
283
284            /* ECMA-48 5.4.2: Parameter string format */
285            if(param < inter)
286            {
287                argv[0] = 0;
288                for(j = param; j < inter; j++)
289                {
290                    if(buffer[i + j] == ';')
291                        argv[++argc] = 0;
292                    else if(buffer[i + j] >= '0' && buffer[i + j] <= '9')
293                        argv[argc] = 10 * argv[argc] + (buffer[i + j] - '0');
294                }
295                argc++;
296            }
297
298            /* Interpret final byte. The code representations are given in
299             * ECMA-48 5.4: Control sequences, and the code definitions are
300             * given in ECMA-48 8.3: Definition of control functions. */
301            switch(buffer[i + final])
302            {
303            case 'f': /* CUP - Cursor Position */
304            case 'H': /* HVP - Character And Line Position */
305                x = (argc > 1) ? argv[1] - 1 : 0;
306                y = (argc > 0) ? argv[0] - 1 : 0;
307                break;
308            case 'A': /* CUU - Cursor Up */
309                y -= argc ? argv[0] : 1;
310                if(y < 0)
311                    y = 0;
312                break;
313            case 'B': /* CUD - Cursor Down */
314                y += argc ? argv[0] : 1;
315                break;
316            case 'C': /* CUF - Cursor Right */
317                x += argc ? argv[0] : 1;
318                break;
319            case 'D': /* CUB - Cursor Left */
320                x -= argc ? argv[0] : 1;
321                if(x < 0)
322                    x = 0;
323                break;
324            case 's': /* Private (save cursor position) */
325                save_x = x;
326                save_y = y;
327                break;
328            case 'u': /* Private (reload cursor positin) */
329                x = save_x;
330                y = save_y;
331                break;
332            case 'J': /* ED - Erase In Page */
333                if(argv[0] == 2)
334                    x = y = 0;
335                break;
336            case 'K': /* EL - Erase In Line */
337                for(j = x; j < width; j++)
338                    _cucul_putchar32(cv, j, y, (uint32_t)' ');
339                x = width;
340                break;
341            case 'm': /* SGR - Select Graphic Rendition */
342                for(j = 0; j < argc; j++)
343                    manage_modifiers(argv[j], &fg, &bg,
344                                     &save_fg, &save_bg, &bold, &reverse);
345                if(bold && fg < 8)
346                    fg += 8;
347                if(bold && bg < 8)
348                    bg += 8;
349                if(reverse)
350                    cucul_set_color(cv, bg, fg);
351                else
352                    cucul_set_color(cv, fg, bg);
353                break;
354            default:
355                break;
356            }
357
358            continue;
359        }
360
361        /* We're going to paste a character. First make sure the canvas
362         * is big enough. */
363        if((unsigned int)x >= width)
364        {
365            x = 0;
366            y++;
367        }
368
369        if((unsigned int)y >= height)
370        {
371            height = y + 1;
372            cucul_set_canvas_size(cv, width, height);
373        }
374
375        /* Now paste our character */
376        _cucul_putchar32(cv, x, y,_cucul_cp437_to_utf32(buffer[i]));
377        x++;
378    }
379
380    return cv;
381}
382
383/* XXX : ANSI loader helper */
384
385static void manage_modifiers(int i, uint8_t *fg, uint8_t *bg, uint8_t *save_fg,
386                             uint8_t *save_bg, uint8_t *bold, uint8_t *reverse)
387{
388    static uint8_t const ansi2cucul[] =
389    {
390        CUCUL_COLOR_BLACK,
391        CUCUL_COLOR_RED,
392        CUCUL_COLOR_GREEN,
393        CUCUL_COLOR_BROWN,
394        CUCUL_COLOR_BLUE,
395        CUCUL_COLOR_MAGENTA,
396        CUCUL_COLOR_CYAN,
397        CUCUL_COLOR_LIGHTGRAY
398    };
399
400    if(i >= 30 && i <= 37)
401        *fg = ansi2cucul[i - 30];
402    else if(i >= 40 && i <= 47)
403        *bg = ansi2cucul[i - 40];
404    else if(i >= 90 && i <= 97)
405        *fg = ansi2cucul[i - 90] + 8;
406    else if(i >= 100 && i <= 107)
407        *bg = ansi2cucul[i - 100] + 8;
408    else switch(i)
409    {
410    case 0:
411        *fg = CUCUL_COLOR_DEFAULT;
412        *bg = CUCUL_COLOR_DEFAULT;
413        *bold = 0;
414        *reverse = 0;
415        break;
416    case 1: /* BOLD */
417        *bold = 1;
418        break;
419    case 4: // Underline
420        break;
421    case 5: // blink
422        break;
423    case 7: // reverse
424        *reverse = 1;
425        break;
426    case 8: // invisible
427        *save_fg = *fg;
428        *save_bg = *bg;
429        *fg = CUCUL_COLOR_TRANSPARENT;
430        *bg = CUCUL_COLOR_TRANSPARENT;
431        break;
432    case 28: // not invisible
433        *fg = *save_fg;
434        *bg = *save_bg;
435        break;
436    case 39:
437        *fg = CUCUL_COLOR_DEFAULT;
438        break;
439    case 49:
440        *bg = CUCUL_COLOR_DEFAULT;
441        break;
442    default:
443        break;
444    }
445}
446
Note: See TracBrowser for help on using the repository browser.