Commit | Line | Data |
---|---|---|
5fc7bf09 KL |
1 | /* |
2 | * Jexer - Java Text User Interface | |
3 | * | |
4 | * The MIT License (MIT) | |
5 | * | |
6 | * Copyright (C) 2019 Kevin Lamonte | |
7 | * | |
8 | * Permission is hereby granted, free of charge, to any person obtaining a | |
9 | * copy of this software and associated documentation files (the "Software"), | |
10 | * to deal in the Software without restriction, including without limitation | |
11 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
12 | * and/or sell copies of the Software, and to permit persons to whom the | |
13 | * Software is furnished to do so, subject to the following conditions: | |
14 | * | |
15 | * The above copyright notice and this permission notice shall be included in | |
16 | * all copies or substantial portions of the Software. | |
17 | * | |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
21 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
23 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | |
24 | * DEALINGS IN THE SOFTWARE. | |
25 | * | |
26 | * @author Kevin Lamonte [kevin.lamonte@gmail.com] | |
27 | * @version 1 | |
28 | */ | |
29 | package jexer.tterminal; | |
30 | ||
31 | import java.awt.Color; | |
32 | import java.awt.Graphics2D; | |
33 | import java.awt.image.BufferedImage; | |
34 | import java.util.ArrayList; | |
35 | import java.util.HashMap; | |
36 | ||
37 | /** | |
38 | * Sixel parses a buffer of sixel image data into a BufferedImage. | |
39 | */ | |
40 | public class Sixel { | |
41 | ||
42 | // ------------------------------------------------------------------------ | |
43 | // Constants -------------------------------------------------------------- | |
44 | // ------------------------------------------------------------------------ | |
45 | ||
46 | /** | |
47 | * Parser character scan states. | |
48 | */ | |
49 | private enum ScanState { | |
50 | GROUND, | |
51 | QUOTE, | |
69a8c368 KL |
52 | COLOR, |
53 | REPEAT, | |
5fc7bf09 KL |
54 | } |
55 | ||
56 | // ------------------------------------------------------------------------ | |
57 | // Variables -------------------------------------------------------------- | |
58 | // ------------------------------------------------------------------------ | |
59 | ||
60 | /** | |
61 | * If true, enable debug messages. | |
62 | */ | |
69a8c368 | 63 | private static boolean DEBUG = false; |
5fc7bf09 KL |
64 | |
65 | /** | |
66 | * Number of pixels to increment when we need more horizontal room. | |
67 | */ | |
68 | private static int WIDTH_INCREASE = 400; | |
69 | ||
70 | /** | |
71 | * Number of pixels to increment when we need more vertical room. | |
72 | */ | |
73 | private static int HEIGHT_INCREASE = 400; | |
74 | ||
75 | /** | |
76 | * Current scanning state. | |
77 | */ | |
78 | private ScanState scanState = ScanState.GROUND; | |
79 | ||
80 | /** | |
81 | * Parameter characters being collected. | |
82 | */ | |
83 | private ArrayList<Integer> colorParams; | |
84 | ||
85 | /** | |
86 | * The sixel palette colors specified. | |
87 | */ | |
88 | private HashMap<Integer, Color> palette; | |
89 | ||
90 | /** | |
91 | * The buffer to parse. | |
92 | */ | |
93 | private String buffer; | |
94 | ||
95 | /** | |
96 | * The image being drawn to. | |
97 | */ | |
98 | private BufferedImage image; | |
99 | ||
100 | /** | |
101 | * The real width of image. | |
102 | */ | |
103 | private int width = 0; | |
104 | ||
105 | /** | |
106 | * The real height of image. | |
107 | */ | |
108 | private int height = 0; | |
109 | ||
110 | /** | |
111 | * The repeat count. | |
112 | */ | |
113 | private int repeatCount = -1; | |
114 | ||
115 | /** | |
116 | * The current drawing x position. | |
117 | */ | |
118 | private int x = 0; | |
119 | ||
120 | /** | |
121 | * The current drawing color. | |
122 | */ | |
123 | private Color color = Color.BLACK; | |
124 | ||
125 | // ------------------------------------------------------------------------ | |
126 | // Constructors ----------------------------------------------------------- | |
127 | // ------------------------------------------------------------------------ | |
128 | ||
129 | /** | |
130 | * Public constructor. | |
131 | * | |
132 | * @param buffer the sixel data to parse | |
133 | */ | |
134 | public Sixel(final String buffer) { | |
135 | this.buffer = buffer; | |
136 | colorParams = new ArrayList<Integer>(); | |
137 | palette = new HashMap<Integer, Color>(); | |
138 | image = new BufferedImage(200, 100, BufferedImage.TYPE_INT_ARGB); | |
139 | for (int i = 0; i < buffer.length(); i++) { | |
140 | consume(buffer.charAt(i)); | |
141 | } | |
142 | } | |
143 | ||
144 | // ------------------------------------------------------------------------ | |
145 | // Sixel ------------------------------------------------------------------ | |
146 | // ------------------------------------------------------------------------ | |
147 | ||
148 | /** | |
149 | * Get the image. | |
150 | * | |
151 | * @return the sixel data as an image. | |
152 | */ | |
153 | public BufferedImage getImage() { | |
154 | if ((width > 0) && (height > 0)) { | |
69a8c368 | 155 | return image.getSubimage(0, 0, width, height + 6); |
5fc7bf09 KL |
156 | } |
157 | return null; | |
158 | } | |
159 | ||
160 | /** | |
161 | * Resize image to a new size. | |
162 | * | |
163 | * @param newWidth new width of image | |
164 | * @param newHeight new height of image | |
165 | */ | |
166 | private void resizeImage(final int newWidth, final int newHeight) { | |
167 | BufferedImage newImage = new BufferedImage(newWidth, newHeight, | |
168 | BufferedImage.TYPE_INT_ARGB); | |
169 | ||
170 | Graphics2D gr = newImage.createGraphics(); | |
171 | gr.drawImage(image, 0, 0, image.getWidth(), image.getHeight(), null); | |
172 | gr.dispose(); | |
173 | image = newImage; | |
174 | } | |
175 | ||
176 | /** | |
177 | * Clear the parameters and flags. | |
178 | */ | |
179 | private void toGround() { | |
180 | colorParams.clear(); | |
181 | scanState = ScanState.GROUND; | |
182 | repeatCount = -1; | |
183 | } | |
184 | ||
185 | /** | |
186 | * Save a byte into the color parameters buffer. | |
187 | * | |
188 | * @param ch byte to save | |
189 | */ | |
190 | private void param(final byte ch) { | |
191 | if (colorParams.size() == 0) { | |
192 | colorParams.add(Integer.valueOf(0)); | |
193 | } | |
194 | Integer n = colorParams.get(colorParams.size() - 1); | |
195 | if ((ch >= '0') && (ch <= '9')) { | |
196 | n *= 10; | |
197 | n += (ch - '0'); | |
198 | colorParams.set(colorParams.size() - 1, n); | |
199 | } | |
200 | ||
201 | if ((ch == ';') && (colorParams.size() < 16)) { | |
202 | colorParams.add(Integer.valueOf(0)); | |
203 | } | |
204 | } | |
205 | ||
206 | /** | |
207 | * Get a color parameter value, with a default. | |
208 | * | |
209 | * @param position parameter index. 0 is the first parameter. | |
210 | * @param defaultValue value to use if colorParams[position] doesn't exist | |
211 | * @return parameter value | |
212 | */ | |
213 | private int getColorParam(final int position, final int defaultValue) { | |
214 | if (colorParams.size() < position + 1) { | |
215 | return defaultValue; | |
216 | } | |
217 | return colorParams.get(position).intValue(); | |
218 | } | |
219 | ||
220 | /** | |
221 | * Get a color parameter value, clamped to within min/max. | |
222 | * | |
223 | * @param position parameter index. 0 is the first parameter. | |
224 | * @param defaultValue value to use if colorParams[position] doesn't exist | |
225 | * @param minValue minimum value inclusive | |
226 | * @param maxValue maximum value inclusive | |
227 | * @return parameter value | |
228 | */ | |
229 | private int getColorParam(final int position, final int defaultValue, | |
230 | final int minValue, final int maxValue) { | |
231 | ||
232 | assert (minValue <= maxValue); | |
233 | int value = getColorParam(position, defaultValue); | |
234 | if (value < minValue) { | |
235 | value = minValue; | |
236 | } | |
237 | if (value > maxValue) { | |
238 | value = maxValue; | |
239 | } | |
240 | return value; | |
241 | } | |
242 | ||
243 | /** | |
244 | * Add sixel data to the image. | |
245 | * | |
246 | * @param ch the character of sixel data | |
247 | */ | |
248 | private void addSixel(final char ch) { | |
249 | int n = ((int) ch - 63); | |
250 | int rgb = color.getRGB(); | |
251 | int rep = (repeatCount == -1 ? 1 : repeatCount); | |
252 | ||
253 | if (DEBUG) { | |
254 | System.err.println("addSixel() rep " + rep + " char " + | |
255 | Integer.toHexString(n) + " color " + color); | |
256 | } | |
257 | ||
69a8c368 KL |
258 | assert (n >= 0); |
259 | ||
5fc7bf09 KL |
260 | if (x + rep > image.getWidth()) { |
261 | // Resize the image, give us another max(rep, WIDTH_INCREASE) | |
262 | // pixels of horizontal length. | |
263 | resizeImage(image.getWidth() + Math.max(rep, WIDTH_INCREASE), | |
264 | image.getHeight()); | |
265 | } | |
266 | ||
267 | // If nothing will be drawn, just advance x. | |
268 | if (n == 0) { | |
269 | x += rep; | |
270 | if (x > width) { | |
271 | width = x; | |
272 | } | |
273 | return; | |
274 | } | |
275 | ||
276 | for (int i = 0; i < rep; i++) { | |
69a8c368 KL |
277 | if ((n & 0x01) != 0) { |
278 | image.setRGB(x, height + 0, rgb); | |
5fc7bf09 | 279 | } |
69a8c368 | 280 | if ((n & 0x02) != 0) { |
5fc7bf09 KL |
281 | image.setRGB(x, height + 1, rgb); |
282 | } | |
69a8c368 | 283 | if ((n & 0x04) != 0) { |
5fc7bf09 KL |
284 | image.setRGB(x, height + 2, rgb); |
285 | } | |
69a8c368 | 286 | if ((n & 0x08) != 0) { |
5fc7bf09 KL |
287 | image.setRGB(x, height + 3, rgb); |
288 | } | |
69a8c368 | 289 | if ((n & 0x10) != 0) { |
5fc7bf09 KL |
290 | image.setRGB(x, height + 4, rgb); |
291 | } | |
69a8c368 | 292 | if ((n & 0x20) != 0) { |
5fc7bf09 KL |
293 | image.setRGB(x, height + 5, rgb); |
294 | } | |
295 | x++; | |
296 | if (x > width) { | |
297 | width++; | |
298 | assert (x == width); | |
299 | } | |
300 | } | |
301 | } | |
302 | ||
303 | /** | |
304 | * Process a color palette change. | |
305 | */ | |
306 | private void setPalette() { | |
307 | int idx = getColorParam(0, 0); | |
308 | ||
309 | if (colorParams.size() == 1) { | |
310 | Color newColor = palette.get(idx); | |
311 | if (newColor != null) { | |
312 | color = newColor; | |
69a8c368 KL |
313 | } else { |
314 | System.err.println("COLOR " + idx + " NOT FOUND"); | |
5fc7bf09 KL |
315 | } |
316 | ||
317 | if (DEBUG) { | |
69a8c368 | 318 | System.err.println("set color " + idx + " " + color); |
5fc7bf09 KL |
319 | } |
320 | return; | |
321 | } | |
322 | ||
323 | int type = getColorParam(1, 0); | |
324 | float red = (float) (getColorParam(2, 0, 0, 100) / 100.0); | |
325 | float green = (float) (getColorParam(3, 0, 0, 100) / 100.0); | |
326 | float blue = (float) (getColorParam(4, 0, 0, 100) / 100.0); | |
327 | ||
328 | if (type == 2) { | |
329 | Color newColor = new Color(red, green, blue); | |
330 | palette.put(idx, newColor); | |
331 | if (DEBUG) { | |
332 | System.err.println("Palette color " + idx + " --> " + newColor); | |
333 | } | |
69a8c368 KL |
334 | } else { |
335 | if (DEBUG) { | |
336 | System.err.println("UNKNOWN COLOR TYPE " + type + ": " + type + | |
337 | " " + idx + " R " + red + " G " + green + " B " + blue); | |
338 | } | |
5fc7bf09 KL |
339 | } |
340 | } | |
341 | ||
342 | /** | |
343 | * Run this input character through the sixel state machine. | |
344 | * | |
345 | * @param ch character from the remote side | |
346 | */ | |
347 | private void consume(char ch) { | |
348 | ||
349 | // DEBUG | |
350 | // System.err.printf("Sixel.consume() %c STATE = %s\n", ch, scanState); | |
351 | ||
69a8c368 KL |
352 | // Between decimal 63 (inclusive) and 127 (exclusive) --> pixels |
353 | if ((ch >= 63) && (ch < 127)) { | |
354 | if (scanState == ScanState.COLOR) { | |
355 | setPalette(); | |
356 | toGround(); | |
5fc7bf09 | 357 | } |
69a8c368 KL |
358 | addSixel(ch); |
359 | toGround(); | |
5fc7bf09 | 360 | return; |
69a8c368 | 361 | } |
5fc7bf09 | 362 | |
69a8c368 KL |
363 | if (ch == '#') { |
364 | // Next color is here, parse what we had before. | |
365 | if (scanState == ScanState.COLOR) { | |
366 | setPalette(); | |
367 | toGround(); | |
5fc7bf09 | 368 | } |
69a8c368 | 369 | scanState = ScanState.COLOR; |
5fc7bf09 | 370 | return; |
69a8c368 | 371 | } |
5fc7bf09 | 372 | |
69a8c368 KL |
373 | if (ch == '!') { |
374 | // Repeat count | |
375 | if (scanState == ScanState.COLOR) { | |
5fc7bf09 KL |
376 | setPalette(); |
377 | toGround(); | |
378 | } | |
69a8c368 KL |
379 | scanState = ScanState.REPEAT; |
380 | repeatCount = 0; | |
381 | return; | |
382 | } | |
5fc7bf09 | 383 | |
69a8c368 KL |
384 | if (ch == '-') { |
385 | if (scanState == ScanState.COLOR) { | |
5fc7bf09 KL |
386 | setPalette(); |
387 | toGround(); | |
69a8c368 | 388 | } |
5fc7bf09 | 389 | |
69a8c368 KL |
390 | if (height + 6 < image.getHeight()) { |
391 | // Resize the image, give us another HEIGHT_INCREASE | |
392 | // pixels of vertical length. | |
393 | resizeImage(image.getWidth(), | |
394 | image.getHeight() + HEIGHT_INCREASE); | |
5fc7bf09 | 395 | } |
69a8c368 KL |
396 | height += 6; |
397 | x = 0; | |
398 | return; | |
399 | } | |
400 | ||
401 | if (ch == '$') { | |
402 | if (scanState == ScanState.COLOR) { | |
5fc7bf09 KL |
403 | setPalette(); |
404 | toGround(); | |
5fc7bf09 | 405 | } |
69a8c368 KL |
406 | x = 0; |
407 | return; | |
408 | } | |
5fc7bf09 | 409 | |
69a8c368 KL |
410 | if (ch == '"') { |
411 | if (scanState == ScanState.COLOR) { | |
5fc7bf09 KL |
412 | setPalette(); |
413 | toGround(); | |
5fc7bf09 | 414 | } |
69a8c368 | 415 | scanState = ScanState.QUOTE; |
5fc7bf09 | 416 | return; |
69a8c368 | 417 | } |
5fc7bf09 | 418 | |
69a8c368 | 419 | switch (scanState) { |
5fc7bf09 | 420 | |
69a8c368 KL |
421 | case GROUND: |
422 | // Unknown character. | |
423 | if (DEBUG) { | |
424 | System.err.println("UNKNOWN CHAR: " + ch); | |
5fc7bf09 | 425 | } |
69a8c368 KL |
426 | return; |
427 | ||
428 | case QUOTE: | |
429 | // Ignore everything else in the quote header. | |
430 | return; | |
5fc7bf09 | 431 | |
69a8c368 KL |
432 | case COLOR: |
433 | // 30-39, 3B --> param | |
5fc7bf09 KL |
434 | if ((ch >= '0') && (ch <= '9')) { |
435 | param((byte) ch); | |
436 | } | |
437 | if (ch == ';') { | |
438 | param((byte) ch); | |
439 | } | |
5fc7bf09 KL |
440 | return; |
441 | ||
69a8c368 | 442 | case REPEAT: |
5fc7bf09 KL |
443 | if ((ch >= '0') && (ch <= '9')) { |
444 | if (repeatCount == -1) { | |
445 | repeatCount = (int) (ch - '0'); | |
446 | } else { | |
447 | repeatCount *= 10; | |
448 | repeatCount += (int) (ch - '0'); | |
449 | } | |
450 | } | |
5fc7bf09 | 451 | return; |
69a8c368 | 452 | |
5fc7bf09 KL |
453 | } |
454 | ||
455 | } | |
456 | ||
457 | } |