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.
 
 
 
 
 
 

456 regels
12 KiB

  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$
  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. * This file contains various import functions.
  15. */
  16. #include "config.h"
  17. #include "common.h"
  18. #if !defined(__KERNEL__)
  19. # include <stdio.h>
  20. # include <stdlib.h>
  21. # include <string.h>
  22. #endif
  23. #include "cucul.h"
  24. #include "cucul_internals.h"
  25. static cucul_canvas_t *import_caca(void const *, unsigned int);
  26. static cucul_canvas_t *import_text(void const *, unsigned int);
  27. static cucul_canvas_t *import_ansi(void const *, unsigned int);
  28. /** \brief Import a buffer into a canvas
  29. *
  30. * This function imports a memory area into an internal libcucul canvas.
  31. *
  32. * Valid values for \c format are:
  33. *
  34. * \li \c "": attempt to autodetect the file format.
  35. *
  36. * \li \c "ansi": import ANSI files.
  37. *
  38. * \li \c "caca": import native libcaca files.
  39. *
  40. * \param data The memory area to be loaded into a canvas.
  41. * \param size The length of the memory area.
  42. * \param format A string describing the input format.
  43. * \return A libcucul canvas, or NULL in case of error.
  44. */
  45. cucul_canvas_t * cucul_import_canvas(void const *data, unsigned int size,
  46. char const *format)
  47. {
  48. char const *buf = (char const*) data;
  49. if(size==0 || data==NULL)
  50. return NULL;
  51. if(!strcasecmp("caca", format))
  52. return import_caca(data, size);
  53. if(!strcasecmp("text", format))
  54. return import_text(data, size);
  55. if(!strcasecmp("ansi", format))
  56. return import_ansi(data, size);
  57. /* Autodetection */
  58. if(!strcasecmp("", format))
  59. {
  60. unsigned int i=0;
  61. /* if 4 first letters are CACA */
  62. if(size >= 4 &&
  63. buf[0] == 'C' && buf[1] == 'A' && buf[2] == 'C' && buf[3] != 'A')
  64. return import_caca(data, size);
  65. /* If we find ESC[ tuple, we guess it's an ANSI file */
  66. while(i<size-1)
  67. {
  68. if((buf[i] == 0x1b) && (buf[i+1] == '['))
  69. return import_ansi(data, size);
  70. i++;
  71. }
  72. /* Otherwise, import it as text */
  73. return import_text(data, size);
  74. }
  75. return NULL;
  76. }
  77. /** \brief Get available import formats
  78. *
  79. * Return a list of available import formats. The list is a NULL-terminated
  80. * array of strings, interleaving a string containing the internal value for
  81. * the import format, to be used with cucul_import_canvas(), and a string
  82. * containing the natural language description for that import format.
  83. *
  84. * \return An array of strings.
  85. */
  86. char const * const * cucul_get_import_list(void)
  87. {
  88. static char const * const list[] =
  89. {
  90. "", "autodetect",
  91. "text", "plain text",
  92. "caca", "native libcaca format",
  93. "ansi", "ANSI coloured text",
  94. NULL, NULL
  95. };
  96. return list;
  97. }
  98. /*
  99. * XXX: the following functions are local.
  100. */
  101. static cucul_canvas_t *import_caca(void const *data, unsigned int size)
  102. {
  103. cucul_canvas_t *cv;
  104. uint8_t const *buf = (uint8_t const *)data;
  105. unsigned int width, height, n;
  106. if(size < 16)
  107. return NULL;
  108. if(buf[0] != 'C' || buf[1] != 'A' || buf[2] != 'C' || buf[3] != 'A')
  109. return NULL;
  110. if(buf[4] != 'C' || buf[5] != 'A' || buf[6] != 'N' || buf[7] != 'V')
  111. return NULL;
  112. width = ((uint32_t)buf[8] << 24) | ((uint32_t)buf[9] << 16)
  113. | ((uint32_t)buf[10] << 8) | (uint32_t)buf[11];
  114. height = ((uint32_t)buf[12] << 24) | ((uint32_t)buf[13] << 16)
  115. | ((uint32_t)buf[14] << 8) | (uint32_t)buf[15];
  116. if(!width || !height)
  117. return NULL;
  118. if(size != 16 + width * height * 8)
  119. return NULL;
  120. cv = cucul_create_canvas(width, height);
  121. if(!cv)
  122. return NULL;
  123. for(n = height * width; n--; )
  124. {
  125. cv->chars[n] = ((uint32_t)buf[16 + 0 + 8 * n] << 24)
  126. | ((uint32_t)buf[16 + 1 + 8 * n] << 16)
  127. | ((uint32_t)buf[16 + 2 + 8 * n] << 8)
  128. | (uint32_t)buf[16 + 3 + 8 * n];
  129. cv->attr[n] = ((uint32_t)buf[16 + 4 + 8 * n] << 24)
  130. | ((uint32_t)buf[16 + 5 + 8 * n] << 16)
  131. | ((uint32_t)buf[16 + 6 + 8 * n] << 8)
  132. | (uint32_t)buf[16 + 7 + 8 * n];
  133. }
  134. return cv;
  135. }
  136. static cucul_canvas_t *import_text(void const *data, unsigned int size)
  137. {
  138. cucul_canvas_t *cv;
  139. char const *text = (char const *)data;
  140. unsigned int width = 1, height = 1, x = 0, y = 0, i;
  141. cv = cucul_create_canvas(width, height);
  142. cucul_set_color(cv, CUCUL_COLOR_DEFAULT, CUCUL_COLOR_TRANSPARENT);
  143. for(i = 0; i < size; i++)
  144. {
  145. unsigned char ch = *text++;
  146. if(ch == '\r')
  147. continue;
  148. if(ch == '\n')
  149. {
  150. x = 0;
  151. y++;
  152. continue;
  153. }
  154. if(x >= width || y >= height)
  155. {
  156. if(x >= width)
  157. width = x + 1;
  158. if(y >= height)
  159. height = y + 1;
  160. cucul_set_canvas_size(cv, width, height);
  161. }
  162. cucul_putchar(cv, x, y, ch);
  163. x++;
  164. }
  165. return cv;
  166. }
  167. #define IS_ALPHA(x) (x>='A' && x<='z')
  168. #define END_TUP 0x1337
  169. static int parse_tuple(unsigned int *, unsigned char const *, int);
  170. static void manage_modifiers(int, uint8_t *, uint8_t *, uint8_t *, uint8_t *, uint8_t *, uint8_t *);
  171. static cucul_canvas_t *import_ansi(void const *data, unsigned int size)
  172. {
  173. cucul_canvas_t *cv;
  174. unsigned char const *buffer = (unsigned char const*)data;
  175. unsigned int i;
  176. unsigned int count = 0;
  177. unsigned int tuple[1024]; /* Should be enough. Will it be ? */
  178. int x = 0, y = 0;
  179. unsigned int width = 80, height = 25;
  180. int save_x = 0, save_y = 0;
  181. unsigned int j, skip;
  182. uint8_t fg, bg, save_fg, save_bg, bold, reverse;
  183. fg = save_fg = CUCUL_COLOR_LIGHTGRAY;
  184. bg = save_bg = CUCUL_COLOR_BLACK;
  185. bold = reverse = 0;
  186. cv = cucul_create_canvas(width, height);
  187. cucul_set_color(cv, fg, bg);
  188. for(i = 0; i < size; i += skip)
  189. {
  190. skip = 1;
  191. if(buffer[i] == '\x1a' && size - i >= 8
  192. && !memcmp(buffer + i + 1, "SAUCE00", 7))
  193. break; /* End before SAUCE data */
  194. if(buffer[i] == '\r')
  195. continue; /* DOS sucks */
  196. if(buffer[i] == '\n')
  197. {
  198. x = 0;
  199. y++;
  200. continue;
  201. }
  202. if(buffer[i] == '\x1b' && buffer[i + 1] == '[') /* ESC code */
  203. {
  204. unsigned char c = '\0';
  205. i++; // ESC
  206. i++; // [
  207. for(j = i; j < size; j++)
  208. if(IS_ALPHA(buffer[j]))
  209. {
  210. c = buffer[j];
  211. break;
  212. }
  213. skip += parse_tuple(tuple, buffer + i, size - i);
  214. count = 0;
  215. while(tuple[count] != END_TUP)
  216. count++; /* Gruik */
  217. switch(c)
  218. {
  219. case 'f':
  220. case 'H':
  221. if(tuple[0] == END_TUP)
  222. x = y = 0;
  223. else
  224. {
  225. y = tuple[0] - 1;
  226. x = tuple[1] == END_TUP ? 0 : tuple[1] - 1;
  227. }
  228. break;
  229. case 'A':
  230. y -= tuple[0] == END_TUP ? 1 : tuple[0];
  231. if(y < 0)
  232. y = 0;
  233. break;
  234. case 'B':
  235. y += tuple[0] == END_TUP ? 1 : tuple[0];
  236. break;
  237. case 'C':
  238. x += tuple[0] == END_TUP ? 1 : tuple[0];
  239. break;
  240. case 'D':
  241. x -= tuple[0] == END_TUP ? 1 : tuple[0];
  242. if(x < 0)
  243. x = 0;
  244. break;
  245. case 's':
  246. save_x = x;
  247. save_y = y;
  248. break;
  249. case 'u':
  250. x = save_x;
  251. y = save_y;
  252. break;
  253. case 'J':
  254. if(tuple[0] == 2)
  255. x = y = 0;
  256. break;
  257. case 'K':
  258. // CLEAR END OF LINE
  259. for(j = x; j < width; j++)
  260. _cucul_putchar32(cv, j, y, (uint32_t)' ');
  261. x = width;
  262. break;
  263. case 'm':
  264. for(j = 0; j < count; j++)
  265. manage_modifiers(tuple[j], &fg, &bg, &save_fg, &save_bg, &bold, &reverse);
  266. if(bold && fg < 8)
  267. fg += 8;
  268. if(bold && bg < 8)
  269. bg += 8;
  270. if(reverse)
  271. cucul_set_color(cv, bg, fg);
  272. else
  273. cucul_set_color(cv, fg, bg);
  274. break;
  275. default:
  276. break;
  277. }
  278. continue;
  279. }
  280. /* We're going to paste a character. First make sure the canvas
  281. * is big enough. */
  282. if(x >= width)
  283. {
  284. x = 0;
  285. y++;
  286. }
  287. if(y >= height)
  288. {
  289. height = y + 1;
  290. cucul_set_canvas_size(cv, width, height);
  291. }
  292. /* Now paste our character */
  293. _cucul_putchar32(cv, x, y,_cucul_cp437_to_utf32(buffer[i]));
  294. x++;
  295. }
  296. return cv;
  297. }
  298. /* XXX : ANSI loader helpers */
  299. static int parse_tuple(unsigned int *ret, unsigned char const *buffer, int size)
  300. {
  301. int i = 0;
  302. int j = 0;
  303. int t = 0;
  304. unsigned char nbr[1024];
  305. ret[0] = END_TUP;
  306. for(i = 0; i < size; i++)
  307. {
  308. if(IS_ALPHA(buffer[i]))
  309. {
  310. if(j != 0)
  311. {
  312. ret[t] = atoi((char*)nbr);
  313. t++;
  314. }
  315. ret[t] = END_TUP;
  316. j = 0;
  317. return i;
  318. }
  319. if(buffer[i] != ';')
  320. {
  321. nbr[j] = buffer[i];
  322. nbr[j + 1] = 0;
  323. j++;
  324. }
  325. else
  326. {
  327. ret[t] = atoi((char*)nbr);
  328. t++;
  329. ret[t] = END_TUP;
  330. j = 0;
  331. }
  332. }
  333. return size;
  334. }
  335. static void manage_modifiers(int i, uint8_t *fg, uint8_t *bg, uint8_t *save_fg, uint8_t *save_bg, uint8_t *bold, uint8_t *reverse)
  336. {
  337. static uint8_t const ansi2cucul[] =
  338. {
  339. CUCUL_COLOR_BLACK,
  340. CUCUL_COLOR_RED,
  341. CUCUL_COLOR_GREEN,
  342. CUCUL_COLOR_BROWN,
  343. CUCUL_COLOR_BLUE,
  344. CUCUL_COLOR_MAGENTA,
  345. CUCUL_COLOR_CYAN,
  346. CUCUL_COLOR_LIGHTGRAY
  347. };
  348. if(i >= 30 && i <= 37)
  349. *fg = ansi2cucul[i - 30];
  350. else if(i >= 40 && i <= 47)
  351. *bg = ansi2cucul[i - 40];
  352. else if(i >= 90 && i <= 97)
  353. *fg = ansi2cucul[i - 90] + 8;
  354. else if(i >= 100 && i <= 107)
  355. *bg = ansi2cucul[i - 100] + 8;
  356. else switch(i)
  357. {
  358. case 0:
  359. *fg = CUCUL_COLOR_DEFAULT;
  360. *bg = CUCUL_COLOR_DEFAULT;
  361. *bold = 0;
  362. *reverse = 0;
  363. break;
  364. case 1: /* BOLD */
  365. *bold = 1;
  366. break;
  367. case 4: // Underline
  368. break;
  369. case 5: // blink
  370. break;
  371. case 7: // reverse
  372. *reverse = 1;
  373. break;
  374. case 8: // invisible
  375. *save_fg = *fg;
  376. *save_bg = *bg;
  377. *fg = CUCUL_COLOR_TRANSPARENT;
  378. *bg = CUCUL_COLOR_TRANSPARENT;
  379. break;
  380. case 28: // not invisible
  381. *fg = *save_fg;
  382. *bg = *save_bg;
  383. break;
  384. case 39:
  385. *fg = CUCUL_COLOR_DEFAULT;
  386. break;
  387. case 49:
  388. *bg = CUCUL_COLOR_DEFAULT;
  389. break;
  390. default:
  391. break;
  392. }
  393. }