/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % SSSSS IIIII X X EEEEE L % % SS I X X E L % % SSS I X EEE L % % SS I X X E L % % SSSSS IIIII X X EEEEE LLLLL % % % % % % Read/Write DEC SIXEL Format % % % % Software Design % % Hayaki Saito % % September 2014 % % Based on kmiya's sixel (2014-03-28) % % % % % % Copyright 1999-2021 ImageMagick Studio LLC, a non-profit organization % % dedicated to making software imaging solutions freely available. % % % % You may not use this file except in compliance with the License. You may % % obtain a copy of the License at % % % % https://imagemagick.org/script/license.php % % % % Unless required by applicable law or agreed to in writing, software % % distributed under the License is distributed on an "AS IS" BASIS, % % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % % See the License for the specific language governing permissions and % % limitations under the License. % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % */ /* Include declarations. */ #include "MagickCore/studio.h" #include "MagickCore/attribute.h" #include "MagickCore/blob.h" #include "MagickCore/blob-private.h" #include "MagickCore/cache.h" #include "MagickCore/color.h" #include "MagickCore/color-private.h" #include "MagickCore/colormap.h" #include "MagickCore/colorspace.h" #include "MagickCore/colorspace-private.h" #include "MagickCore/exception.h" #include "MagickCore/exception-private.h" #include "MagickCore/geometry.h" #include "MagickCore/image.h" #include "MagickCore/image-private.h" #include "MagickCore/list.h" #include "MagickCore/magick.h" #include "MagickCore/memory_.h" #include "MagickCore/monitor.h" #include "MagickCore/monitor-private.h" #include "MagickCore/pixel-accessor.h" #include "MagickCore/pixel-private.h" #include "MagickCore/quantize.h" #include "MagickCore/quantum-private.h" #include "MagickCore/resize.h" #include "MagickCore/resource_.h" #include "MagickCore/splay-tree.h" #include "MagickCore/static.h" #include "MagickCore/string_.h" #include "MagickCore/thread-private.h" #include "MagickCore/module.h" #include "MagickCore/threshold.h" #include "MagickCore/utility.h" /* Definitions */ #define SIXEL_PALETTE_MAX 1024 #define SIXEL_OUTPUT_PACKET_SIZE 1024 /* Macros */ #define SIXEL_RGB(r, g, b) ((int) (((ssize_t) (r) << 16) + ((g) << 8) + (b))) #define SIXEL_PALVAL(n,a,m) ((int) (((ssize_t) (n) * (a) + ((m) / 2)) / (m))) #define SIXEL_XRGB(r,g,b) SIXEL_RGB(SIXEL_PALVAL(r, 255, 100), SIXEL_PALVAL(g, 255, 100), SIXEL_PALVAL(b, 255, 100)) typedef unsigned short sixel_pixel_t; /* Structure declarations. */ typedef struct sixel_node { struct sixel_node *next; int color; int left; int right; sixel_pixel_t *map; } sixel_node_t; typedef struct sixel_output { /* compatiblity flags */ /* 0: 7bit terminal, * 1: 8bit terminal */ unsigned char has_8bit_control; int save_pixel; int save_count; int active_palette; sixel_node_t *node_top; sixel_node_t *node_free; Image *image; int pos; unsigned char buffer[1]; } sixel_output_t; static int const sixel_default_color_table[] = { SIXEL_XRGB(0, 0, 0), /* 0 Black */ SIXEL_XRGB(20, 20, 80), /* 1 Blue */ SIXEL_XRGB(80, 13, 13), /* 2 Red */ SIXEL_XRGB(20, 80, 20), /* 3 Green */ SIXEL_XRGB(80, 20, 80), /* 4 Magenta */ SIXEL_XRGB(20, 80, 80), /* 5 Cyan */ SIXEL_XRGB(80, 80, 20), /* 6 Yellow */ SIXEL_XRGB(53, 53, 53), /* 7 Gray 50% */ SIXEL_XRGB(26, 26, 26), /* 8 Gray 25% */ SIXEL_XRGB(33, 33, 60), /* 9 Blue* */ SIXEL_XRGB(60, 26, 26), /* 10 Red* */ SIXEL_XRGB(33, 60, 33), /* 11 Green* */ SIXEL_XRGB(60, 33, 60), /* 12 Magenta* */ SIXEL_XRGB(33, 60, 60), /* 13 Cyan* */ SIXEL_XRGB(60, 60, 33), /* 14 Yellow* */ SIXEL_XRGB(80, 80, 80), /* 15 Gray 75% */ }; /* Forward declarations. */ static MagickBooleanType WriteSIXELImage(const ImageInfo *,Image *,ExceptionInfo *); static int hue_to_rgb(int n1, int n2, int hue) { const int HLSMAX = 100; if (hue < 0) { hue += HLSMAX; } if (hue > HLSMAX) { hue -= HLSMAX; } if (hue < (HLSMAX / 6)) { return (n1 + (((n2 - n1) * hue + (HLSMAX / 12)) / (HLSMAX / 6))); } if (hue < (HLSMAX / 2)) { return (n2); } if (hue < ((HLSMAX * 2) / 3)) { return (n1 + (((n2 - n1) * (((HLSMAX * 2) / 3) - hue) + (HLSMAX / 12))/(HLSMAX / 6))); } return (n1); } static int hls_to_rgb(int hue, int lum, int sat) { int R, G, B; int Magic1, Magic2; const int RGBMAX = 255; const int HLSMAX = 100; if (sat == 0) { R = G = B = (lum * RGBMAX) / HLSMAX; } else { if (lum <= (HLSMAX / 2)) { Magic2 = (int) (((ssize_t) lum * (HLSMAX + sat) + (HLSMAX / 2)) / HLSMAX); } else { Magic2 = (int) (lum + sat - (((ssize_t) lum * sat) + (HLSMAX / 2)) / HLSMAX); } Magic1 = 2 * lum - Magic2; R = (hue_to_rgb(Magic1, Magic2, hue + (HLSMAX / 3)) * RGBMAX + (HLSMAX / 2)) / HLSMAX; G = (hue_to_rgb(Magic1, Magic2, hue) * RGBMAX + (HLSMAX / 2)) / HLSMAX; B = (hue_to_rgb(Magic1, Magic2, hue - (HLSMAX / 3)) * RGBMAX + (HLSMAX/2)) / HLSMAX; } return SIXEL_RGB(R, G, B); } static unsigned char *get_params(unsigned char *p, int *param, int *len) { int n; *len = 0; while (*p != '\0') { while (*p == ' ' || *p == '\t') { p++; } if (isdigit((int) ((unsigned char) *p))) { for (n = 0; isdigit((int) ((unsigned char) *p)); p++) { if (n <= (INT_MAX/10)) n = (int) ((ssize_t) n * 10 + (*p - '0')); } if (*len < 10) { param[(*len)++] = n; } while (*p == ' ' || *p == '\t') { p++; } if (*p == ';') { p++; } } else if (*p == ';') { if (*len < 10) { param[(*len)++] = 0; } p++; } else break; } return p; } /* convert sixel data into indexed pixel bytes and palette data */ MagickBooleanType sixel_decode(Image *image, unsigned char /* in */ *p, /* sixel bytes */ sixel_pixel_t /* out */ **pixels, /* decoded pixels */ size_t /* out */ *pwidth, /* image width */ size_t /* out */ *pheight, /* image height */ unsigned char /* out */ **palette, /* ARGB palette */ size_t /* out */ *ncolors, /* palette size (<= SIXEL_PALETTE_MAX) */ ExceptionInfo *exception) { int n, i, r, g, b, sixel_vertical_mask, c; int posision_x, posision_y; int max_x, max_y; int attributed_pan, attributed_pad; int attributed_ph, attributed_pv; int repeat_count, color_index, max_color_index = 2, background_color_index; int param[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; int sixel_palet[SIXEL_PALETTE_MAX]; sixel_pixel_t *imbuf, *dmbuf; int imsx, imsy; int dmsx, dmsy; int x, y; size_t extent,offset; extent=strlen((char *) p); posision_x = posision_y = 0; max_x = max_y = 0; attributed_pan = 2; attributed_pad = 1; attributed_ph = attributed_pv = 0; repeat_count = 1; color_index = 0; background_color_index = 0; imsx = 2048; imsy = 2048; if (SetImageExtent(image,imsx,imsy,exception) == MagickFalse) return(MagickFalse); imbuf=(sixel_pixel_t *) AcquireQuantumMemory(imsx,imsy* sizeof(sixel_pixel_t)); if (imbuf == NULL) { return(MagickFalse); } for (n = 0; n < 16; n++) { sixel_palet[n] = sixel_default_color_table[n]; } /* colors 16-231 are a 6x6x6 color cube */ for (r = 0; r < 6; r++) { for (g = 0; g < 6; g++) { for (b = 0; b < 6; b++) { sixel_palet[n++] = SIXEL_RGB(r * 51, g * 51, b * 51); } } } /* colors 232-255 are a grayscale ramp, intentionally leaving out */ for (i = 0; i < 24; i++) { sixel_palet[n++] = SIXEL_RGB(i * 11, i * 11, i * 11); } for (; n < SIXEL_PALETTE_MAX; n++) { sixel_palet[n] = SIXEL_RGB(255, 255, 255); } for (i = 0; i < imsx * imsy; i++) { imbuf[i] = background_color_index; } while (*p != '\0') { if ((p[0] == '\033' && p[1] == 'P') || *p == 0x90) { if (*p == '\033') { p++; } p = get_params(++p, param, &n); if (*p == 'q') { p++; if (n > 0) { /* Pn1 */ switch(param[0]) { case 0: case 1: attributed_pad = 2; break; case 2: attributed_pad = 5; break; case 3: attributed_pad = 4; break; case 4: attributed_pad = 4; break; case 5: attributed_pad = 3; break; case 6: attributed_pad = 3; break; case 7: attributed_pad = 2; break; case 8: attributed_pad = 2; break; case 9: attributed_pad = 1; break; } } if (n > 2) { /* Pn3 */ if (param[2] == 0) { param[2] = 10; } attributed_pan = (int) (((ssize_t) attributed_pan * param[2]) / 10); attributed_pad = (int) (((ssize_t) attributed_pad * param[2]) / 10); if (attributed_pan <= 0) attributed_pan = 1; if (attributed_pad <= 0) attributed_pad = 1; } } } else if ((p[0] == '\033' && p[1] == '\\') || *p == 0x9C) { break; } else if (*p == '"') { /* DECGRA Set Raster Attributes " Pan; Pad; Ph; Pv */ p = get_params(++p, param, &n); if (n > 0) attributed_pad = param[0]; if (n > 1) attributed_pan = param[1]; if (n > 2 && param[2] > 0) attributed_ph = param[2] & 0xffff; if (n > 3 && param[3] > 0) attributed_pv = param[3] & 0xffff; if (attributed_pan <= 0) attributed_pan = 1; if (attributed_pad <= 0) attributed_pad = 1; if (imsx < attributed_ph || imsy < attributed_pv) { dmsx = imsx > attributed_ph ? imsx : attributed_ph; dmsy = imsy > attributed_pv ? imsy : attributed_pv; if (SetImageExtent(image,dmsx,dmsy,exception) == MagickFalse) break; dmbuf = (sixel_pixel_t *) AcquireQuantumMemory(dmsx,dmsy*sizeof(sixel_pixel_t)); if (dmbuf == (sixel_pixel_t *) NULL) { imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); return (MagickFalse); } (void) memset(dmbuf, background_color_index, (size_t) dmsx * dmsy * sizeof(sixel_pixel_t)); for (y = 0; y < imsy; ++y) { (void) memcpy(dmbuf + dmsx * y, imbuf + imsx * y, imsx * sizeof(sixel_pixel_t)); } imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); imsx = dmsx; imsy = dmsy; imbuf = dmbuf; } } else if (*p == '!') { /* DECGRI Graphics Repeat Introducer ! Pn Ch */ p = get_params(++p, param, &n); if ((n > 0) && (param[0] > 0)) { repeat_count = param[0]; if (repeat_count > (ssize_t) extent) break; } } else if (*p == '#') { /* DECGCI Graphics Color Introducer # Pc; Pu; Px; Py; Pz */ p = get_params(++p, param, &n); if (n > 0) { if ((color_index = param[0]) < 0) { color_index = 0; } else if (color_index >= SIXEL_PALETTE_MAX) { color_index = SIXEL_PALETTE_MAX - 1; } } if (n > 4) { if (param[1] == 1) { /* HLS */ if (param[2] > 360) param[2] = 360; if (param[3] > 100) param[3] = 100; if (param[4] > 100) param[4] = 100; sixel_palet[color_index] = hls_to_rgb((int) ((ssize_t) param[2] * 100 / 360), param[3], param[4]); } else if (param[1] == 2) { /* RGB */ if (param[2] > 100) param[2] = 100; if (param[3] > 100) param[3] = 100; if (param[4] > 100) param[4] = 100; sixel_palet[color_index] = SIXEL_XRGB(param[2], param[3], param[4]); } } } else if (*p == '$') { /* DECGCR Graphics Carriage Return */ p++; posision_x = 0; repeat_count = 1; } else if (*p == '-') { /* DECGNL Graphics Next Line */ p++; posision_x = 0; posision_y += 6; repeat_count = 1; } else if (*p >= '?' && *p <= '\177') { if (imsx < (posision_x + repeat_count) || imsy < (posision_y + 6)) { int nx = imsx * 2; int ny = imsy * 2; while (nx < (posision_x + repeat_count) || ny < (posision_y + 6)) { nx *= 2; ny *= 2; } dmsx = nx; dmsy = ny; if (SetImageExtent(image,dmsx,dmsy,exception) == MagickFalse) break; dmbuf = (sixel_pixel_t *) AcquireQuantumMemory(dmsx, dmsy*sizeof(sixel_pixel_t)); if (dmbuf == (sixel_pixel_t *) NULL) { imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); return (MagickFalse); } (void) memset(dmbuf, background_color_index, (size_t) dmsx * dmsy * sizeof(sixel_pixel_t)); for (y = 0; y < imsy; ++y) { (void) memcpy(dmbuf + dmsx * y, imbuf + imsx * y, imsx * sizeof(sixel_pixel_t)); } imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); imsx = dmsx; imsy = dmsy; imbuf = dmbuf; } if (color_index > max_color_index) { max_color_index = color_index; } if ((b = *(p++) - '?') == 0) { posision_x += repeat_count; } else { sixel_vertical_mask = 0x01; if (repeat_count <= 1) { for (i = 0; i < 6; i++) { if ((b & sixel_vertical_mask) != 0) { offset=(size_t) imsx * (posision_y + i) + posision_x; if (offset >= (size_t) imsx * imsy) { imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); return (MagickFalse); } imbuf[offset] = color_index; if (max_x < posision_x) { max_x = posision_x; } if (max_y < (posision_y + i)) { max_y = posision_y + i; } } sixel_vertical_mask <<= 1; } posision_x += 1; } else { /* repeat_count > 1 */ for (i = 0; i < 6; i++) { if ((b & sixel_vertical_mask) != 0) { c = sixel_vertical_mask << 1; for (n = 1; (i + n) < 6; n++) { if ((b & c) == 0) { break; } c <<= 1; } for (y = posision_y + i; y < posision_y + i + n; ++y) { offset=(size_t) imsx * y + posision_x; if (offset + repeat_count >= (size_t) imsx * imsy) { imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); return (MagickFalse); } for (x = 0; x < repeat_count; x++) { imbuf[offset+x] = color_index; } } if (max_x < (posision_x + repeat_count - 1)) { max_x = posision_x + repeat_count - 1; } if (max_y < (posision_y + i + n - 1)) { max_y = posision_y + i + n - 1; } i += (n - 1); sixel_vertical_mask <<= (n - 1); } sixel_vertical_mask <<= 1; } posision_x += repeat_count; } } repeat_count = 1; } else { p++; } } if (++max_x < attributed_ph) { max_x = attributed_ph; } if (++max_y < attributed_pv) { max_y = attributed_pv; } if (imsx > max_x || imsy > max_y) { dmsx = max_x; dmsy = max_y; if (SetImageExtent(image,dmsx,dmsy,exception) == MagickFalse) { imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); return (MagickFalse); } if ((dmbuf = (sixel_pixel_t *) AcquireQuantumMemory(dmsx,dmsy*sizeof(sixel_pixel_t))) == NULL) { imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); return (MagickFalse); } for (y = 0; y < dmsy; ++y) { (void) memcpy(dmbuf + dmsx * y, imbuf + imsx * y, dmsx * sizeof(sixel_pixel_t)); } imbuf = (sixel_pixel_t *) RelinquishMagickMemory(imbuf); imsx = dmsx; imsy = dmsy; imbuf = dmbuf; } *pixels = imbuf; *pwidth = imsx; *pheight = imsy; *ncolors = max_color_index + 1; *palette = (unsigned char *) AcquireQuantumMemory(*ncolors,4); if (*palette == (unsigned char *) NULL) return(MagickFalse); for (n = 0; n < (ssize_t) *ncolors; ++n) { (*palette)[n * 4 + 0] = sixel_palet[n] >> 16 & 0xff; (*palette)[n * 4 + 1] = sixel_palet[n] >> 8 & 0xff; (*palette)[n * 4 + 2] = sixel_palet[n] & 0xff; (*palette)[n * 4 + 3] = 0xff; } return(MagickTrue); } sixel_output_t *sixel_output_create(Image *image) { sixel_output_t *output; output = (sixel_output_t *) AcquireQuantumMemory(sizeof(sixel_output_t) + SIXEL_OUTPUT_PACKET_SIZE * 2, 1); if (output == (sixel_output_t *) NULL) return((sixel_output_t *) NULL); output->has_8bit_control = 0; output->save_pixel = 0; output->save_count = 0; output->active_palette = (-1); output->node_top = NULL; output->node_free = NULL; output->image = image; output->pos = 0; return output; } static void sixel_advance(sixel_output_t *context, int nwrite) { if ((context->pos += nwrite) >= SIXEL_OUTPUT_PACKET_SIZE) { WriteBlob(context->image,SIXEL_OUTPUT_PACKET_SIZE,context->buffer); memmove(context->buffer, context->buffer + SIXEL_OUTPUT_PACKET_SIZE, (context->pos -= SIXEL_OUTPUT_PACKET_SIZE)); } } static int sixel_put_flash(sixel_output_t *const context) { int n; int nwrite; #if defined(USE_VT240) /* VT240 Max 255 ? */ while (context->save_count > 255) { nwrite = spritf((char *)context->buffer + context->pos, "!255%c", context->save_pixel); if (nwrite <= 0) { return (-1); } sixel_advance(context, nwrite); context->save_count -= 255; } #endif /* defined(USE_VT240) */ if (context->save_count > 3) { /* DECGRI Graphics Repeat Introducer ! Pn Ch */ nwrite = sprintf((char *)context->buffer + context->pos, "!%d%c", context->save_count, context->save_pixel); if (nwrite <= 0) { return (-1); } sixel_advance(context, nwrite); } else { for (n = 0; n < context->save_count; n++) { context->buffer[context->pos] = (char)context->save_pixel; sixel_advance(context, 1); } } context->save_pixel = 0; context->save_count = 0; return 0; } static void sixel_put_pixel(sixel_output_t *const context, int pix) { if (pix < 0 || pix > '?') { pix = 0; } pix += '?'; if (pix == context->save_pixel) { context->save_count++; } else { sixel_put_flash(context); context->save_pixel = pix; context->save_count = 1; } } static void sixel_node_del(sixel_output_t *const context, sixel_node_t *np) { sixel_node_t *tp; if ((tp = context->node_top) == np) { context->node_top = np->next; } else { while (tp->next != NULL) { if (tp->next == np) { tp->next = np->next; break; } tp = tp->next; } } np->next = context->node_free; context->node_free = np; } static int sixel_put_node(sixel_output_t *const context, int x, sixel_node_t *np, int ncolors, int keycolor) { int nwrite; if (ncolors != 2 || keycolor == -1) { /* designate palette index */ if (context->active_palette != np->color) { nwrite = sprintf((char *)context->buffer + context->pos, "#%d", np->color); sixel_advance(context, nwrite); context->active_palette = np->color; } } for (; x < np->left; x++) { sixel_put_pixel(context, 0); } for (; x < np->right; x++) { sixel_put_pixel(context, np->map[x]); } sixel_put_flash(context); return x; } static MagickBooleanType sixel_encode_impl(sixel_pixel_t *pixels, size_t width,size_t height, unsigned char *palette, size_t ncolors, int keycolor, sixel_output_t *context) { #define RelinquishNodesAndMap \ while ((np = context->node_free) != NULL) { \ context->node_free = np->next; \ np=(sixel_node_t *) RelinquishMagickMemory(np); \ } \ map = (sixel_pixel_t *) RelinquishMagickMemory(map) int x, y, i, n, c; int left, right; int pix; sixel_pixel_t *map; sixel_node_t *np, *tp, top; int nwrite; size_t len; context->pos = 0; if (ncolors < 1) { return (MagickFalse); } len = ncolors * width; context->active_palette = (-1); if ((map = (sixel_pixel_t *)AcquireQuantumMemory(len, sizeof(sixel_pixel_t))) == NULL) { return (MagickFalse); } (void) memset(map, 0, len * sizeof(sixel_pixel_t)); if (context->has_8bit_control) { nwrite = sprintf((char *)context->buffer, "\x90" "0;0;0" "q"); } else { nwrite = sprintf((char *)context->buffer, "\x1bP" "0;0;0" "q"); } if (nwrite <= 0) { return (MagickFalse); } sixel_advance(context, nwrite); nwrite = sprintf((char *)context->buffer + context->pos, "\"1;1;%d;%d", (int) width, (int) height); if (nwrite <= 0) { RelinquishNodesAndMap; return (MagickFalse); } sixel_advance(context, nwrite); if (ncolors != 2 || keycolor == -1) { for (n = 0; n < (ssize_t) ncolors; n++) { /* DECGCI Graphics Color Introducer # Pc ; Pu; Px; Py; Pz */ nwrite = sprintf((char *)context->buffer + context->pos, "#%d;2;%d;%d;%d", n, (palette[n * 3 + 0] * 100 + 127) / 255, (palette[n * 3 + 1] * 100 + 127) / 255, (palette[n * 3 + 2] * 100 + 127) / 255); if (nwrite <= 0) { RelinquishNodesAndMap; return (MagickFalse); } sixel_advance(context, nwrite); if (nwrite <= 0) { RelinquishNodesAndMap; return (MagickFalse); } } } for (y = i = 0; y < (ssize_t) height; y++) { for (x = 0; x < (ssize_t) width; x++) { pix = pixels[y * width + x]; if (pix >= 0 && pix < (ssize_t) ncolors && pix != keycolor) { map[pix * width + x] |= (1 << i); } } if (++i < 6 && (y + 1) < (ssize_t) height) { continue; } for (c = 0; c < (ssize_t) ncolors; c++) { for (left = 0; left < (ssize_t) width; left++) { if (*(map + c * width + left) == 0) { continue; } for (right = left + 1; right < (ssize_t) width; right++) { if (*(map + c * width + right) != 0) { continue; } for (n = 1; (right + n) < (ssize_t) width; n++) { if (*(map + c * width + right + n) != 0) { break; } } if (n >= 10 || right + n >= (ssize_t) width) { break; } right = right + n - 1; } if ((np = context->node_free) != NULL) { context->node_free = np->next; } else if ((np = (sixel_node_t *)AcquireMagickMemory(sizeof(sixel_node_t))) == NULL) { RelinquishNodesAndMap; return (MagickFalse); } np->color = c; np->left = left; np->right = right; np->map = map + c * width; top.next = context->node_top; tp = ⊤ while (tp->next != NULL) { if (np->left < tp->next->left) { break; } if (np->left == tp->next->left && np->right > tp->next->right) { break; } tp = tp->next; } np->next = tp->next; tp->next = np; context->node_top = top.next; left = right - 1; } } for (x = 0; (np = context->node_top) != NULL;) { if (x > np->left) { /* DECGCR Graphics Carriage Return */ context->buffer[context->pos] = '$'; sixel_advance(context, 1); x = 0; } x = sixel_put_node(context, x, np, (int) ncolors, keycolor); sixel_node_del(context, np); np = context->node_top; while (np != NULL) { if (np->left < x) { np = np->next; continue; } x = sixel_put_node(context, x, np, (int) ncolors, keycolor); sixel_node_del(context, np); np = context->node_top; } } /* DECGNL Graphics Next Line */ context->buffer[context->pos] = '-'; sixel_advance(context, 1); if (nwrite <= 0) { RelinquishNodesAndMap; return (MagickFalse); } i = 0; (void) memset(map, 0, len * sizeof(sixel_pixel_t)); } if (context->has_8bit_control) { context->buffer[context->pos] = 0x9c; sixel_advance(context, 1); } else { context->buffer[context->pos] = 0x1b; context->buffer[context->pos + 1] = '\\'; sixel_advance(context, 2); } if (nwrite <= 0) { RelinquishNodesAndMap; return (MagickFalse); } /* flush buffer */ if (context->pos > 0) { WriteBlob(context->image,context->pos,context->buffer); } RelinquishNodesAndMap; return(MagickTrue); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % I s S I X E L % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % IsSIXEL() returns MagickTrue if the image format type, identified by the % magick string, is SIXEL. % % The format of the IsSIXEL method is: % % MagickBooleanType IsSIXEL(const unsigned char *magick, % const size_t length) % % A description of each parameter follows: % % o magick: compare image format pattern against these bytes. or % blob. % % o length: Specifies the length of the magick string. % */ static MagickBooleanType IsSIXEL(const unsigned char *magick, const size_t length) { const unsigned char *end = magick + length; if (length < 3) return(MagickFalse); if (*magick == 0x90 || (*magick == 0x1b && *++magick == 'P')) { while (++magick != end) { if (*magick == 'q') return(MagickTrue); if (!(*magick >= '0' && *magick <= '9') && *magick != ';') return(MagickFalse); } } return(MagickFalse); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e a d S I X E L I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ReadSIXELImage() reads an X11 pixmap image file and returns it. It % allocates the memory necessary for the new Image structure and returns a % pointer to the new image. % % The format of the ReadSIXELImage method is: % % Image *ReadSIXELImage(const ImageInfo *image_info, % ExceptionInfo *exception) % % A description of each parameter follows: % % o image_info: the image info. % % o exception: return any errors or warnings in this structure. % */ static Image *ReadSIXELImage(const ImageInfo *image_info,ExceptionInfo *exception) { char *sixel_buffer; Image *image; MagickBooleanType status; char *p; ssize_t x; Quantum *q; size_t length; ssize_t i, j, y; sixel_pixel_t *sixel_pixels; unsigned char *sixel_palette; /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickCoreSignature); if (image_info->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", image_info->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickCoreSignature); image=AcquireImage(image_info,exception); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) { image=DestroyImageList(image); return((Image *) NULL); } /* Read SIXEL file. */ length=MagickPathExtent; sixel_buffer=(char *) AcquireQuantumMemory((size_t) length+MagickPathExtent, sizeof(*sixel_buffer)); p=sixel_buffer; if (sixel_buffer != (char *) NULL) while (ReadBlobString(image,p) != (char *) NULL) { if ((*p == '#') && ((p == sixel_buffer) || (*(p-1) == '\n'))) continue; if ((*p == '}') && (*(p+1) == ';')) break; p+=strlen(p); if ((size_t) (p-sixel_buffer+MagickPathExtent+1) < length) continue; length<<=1; sixel_buffer=(char *) ResizeQuantumMemory(sixel_buffer,length+ MagickPathExtent+1,sizeof(*sixel_buffer)); if (sixel_buffer == (char *) NULL) break; p=sixel_buffer+strlen(sixel_buffer); } if (sixel_buffer == (char *) NULL) ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); sixel_buffer[length]='\0'; /* Decode SIXEL */ sixel_pixels=(sixel_pixel_t *) NULL; if (sixel_decode(image,(unsigned char *) sixel_buffer,&sixel_pixels,&image->columns,&image->rows,&sixel_palette,&image->colors,exception) == MagickFalse) { sixel_buffer=(char *) RelinquishMagickMemory(sixel_buffer); if (sixel_pixels != (sixel_pixel_t *) NULL) sixel_pixels=(sixel_pixel_t *) RelinquishMagickMemory(sixel_pixels); ThrowReaderException(CorruptImageError,"CorruptImage"); } sixel_buffer=(char *) RelinquishMagickMemory(sixel_buffer); image->depth=24; image->storage_class=PseudoClass; status=SetImageExtent(image,image->columns,image->rows,exception); if (status == MagickFalse) { sixel_pixels=(sixel_pixel_t *) RelinquishMagickMemory(sixel_pixels); sixel_palette=(unsigned char *) RelinquishMagickMemory(sixel_palette); return(DestroyImageList(image)); } if (AcquireImageColormap(image,image->colors, exception) == MagickFalse) { sixel_pixels=(sixel_pixel_t *) RelinquishMagickMemory(sixel_pixels); sixel_palette=(unsigned char *) RelinquishMagickMemory(sixel_palette); ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed"); } for (i = 0; i < (ssize_t) image->colors; ++i) { image->colormap[i].red = ScaleCharToQuantum(sixel_palette[i * 4 + 0]); image->colormap[i].green = ScaleCharToQuantum(sixel_palette[i * 4 + 1]); image->colormap[i].blue = ScaleCharToQuantum(sixel_palette[i * 4 + 2]); } j=0; if (image_info->ping == MagickFalse) { /* Read image pixels. */ for (y=0; y < (ssize_t) image->rows; y++) { q=QueueAuthenticPixels(image,0,y,image->columns,1,exception); if (q == (Quantum *) NULL) break; for (x=0; x < (ssize_t) image->columns; x++) { j=(ssize_t) sixel_pixels[y * image->columns + x]; SetPixelIndex(image,j,q); q+=GetPixelChannels(image); } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } if (y < (ssize_t) image->rows) { sixel_pixels=(sixel_pixel_t *) RelinquishMagickMemory(sixel_pixels); sixel_palette=(unsigned char *) RelinquishMagickMemory(sixel_palette); ThrowReaderException(CorruptImageError,"NotEnoughPixelData"); } } /* Relinquish resources. */ sixel_pixels=(sixel_pixel_t *) RelinquishMagickMemory(sixel_pixels); sixel_palette=(unsigned char *) RelinquishMagickMemory(sixel_palette); (void) CloseBlob(image); return(GetFirstImageInList(image)); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % R e g i s t e r S I X E L I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % RegisterSIXELImage() adds attributes for the SIXEL image format to % the list of supported formats. The attributes include the image format % tag, a method to read and/or write the format, whether the format % supports the saving of more than one frame to the same file or blob, % whether the format supports native in-memory I/O, and a brief % description of the format. % % The format of the RegisterSIXELImage method is: % % size_t RegisterSIXELImage(void) % */ ModuleExport size_t RegisterSIXELImage(void) { MagickInfo *entry; entry=AcquireMagickInfo("SIXEL","SIXEL","DEC SIXEL Graphics Format"); entry->decoder=(DecodeImageHandler *) ReadSIXELImage; entry->encoder=(EncodeImageHandler *) WriteSIXELImage; entry->magick=(IsImageFormatHandler *) IsSIXEL; entry->flags^=CoderAdjoinFlag; (void) RegisterMagickInfo(entry); entry=AcquireMagickInfo("SIXEL","SIX","DEC SIXEL Graphics Format"); entry->decoder=(DecodeImageHandler *) ReadSIXELImage; entry->encoder=(EncodeImageHandler *) WriteSIXELImage; entry->magick=(IsImageFormatHandler *) IsSIXEL; entry->flags^=CoderAdjoinFlag; (void) RegisterMagickInfo(entry); return(MagickImageCoderSignature); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % U n r e g i s t e r S I X E L I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % UnregisterSIXELImage() removes format registrations made by the % SIXEL module from the list of supported formats. % % The format of the UnregisterSIXELImage method is: % % UnregisterSIXELImage(void) % */ ModuleExport void UnregisterSIXELImage(void) { (void) UnregisterMagickInfo("SIXEL"); (void) UnregisterMagickInfo("SIX"); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % W r i t e S I X E L I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % WriteSIXELImage() writes an image to a file in the X pixmap format. % % The format of the WriteSIXELImage method is: % % MagickBooleanType WriteSIXELImage(const ImageInfo *image_info, % Image *image,ExceptionInfo *exception) % % A description of each parameter follows. % % o image_info: the image info. % % o image: The image. % % o exception: return any errors or warnings in this structure. % */ static MagickBooleanType WriteSIXELImage(const ImageInfo *image_info, Image *image,ExceptionInfo *exception) { MagickBooleanType status; const Quantum *q; ssize_t i, x; ssize_t opacity, y; sixel_output_t *output; unsigned char sixel_palette[SIXEL_PALETTE_MAX*3]; sixel_pixel_t *sixel_pixels; /* Open output image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickCoreSignature); assert(image != (Image *) NULL); assert(image->signature == MagickCoreSignature); if (image->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename); status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception); if (status == MagickFalse) return(status); if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse) (void) TransformImageColorspace(image,sRGBColorspace,exception); opacity=(-1); if (image->alpha_trait == UndefinedPixelTrait) { if ((image->storage_class == DirectClass) || (image->colors > SIXEL_PALETTE_MAX)) (void) SetImageType(image,PaletteType,exception); } else { MagickRealType alpha, beta; /* Identify transparent colormap index. */ if ((image->storage_class == DirectClass) || (image->colors > SIXEL_PALETTE_MAX)) (void) SetImageType(image,PaletteBilevelAlphaType,exception); for (i=0; i < (ssize_t) image->colors; i++) if (image->colormap[i].alpha != OpaqueAlpha) { if (opacity < 0) { opacity=i; continue; } alpha=image->colormap[i].alpha; beta=image->colormap[opacity].alpha; if (alpha < beta) opacity=i; } if (opacity == -1) { (void) SetImageType(image,PaletteBilevelAlphaType,exception); for (i=0; i < (ssize_t) image->colors; i++) if (image->colormap[i].alpha != OpaqueAlpha) { if (opacity < 0) { opacity=i; continue; } alpha=image->colormap[i].alpha; beta=image->colormap[opacity].alpha; if (alpha < beta) opacity=i; } } if (opacity >= 0) { image->colormap[opacity].red=image->transparent_color.red; image->colormap[opacity].green=image->transparent_color.green; image->colormap[opacity].blue=image->transparent_color.blue; } } /* SIXEL header. */ for (i=0; i < (ssize_t) image->colors; i++) { sixel_palette[3*i+0]=ScaleQuantumToChar(image->colormap[i].red); sixel_palette[3*i+1]=ScaleQuantumToChar(image->colormap[i].green); sixel_palette[3*i+2]=ScaleQuantumToChar(image->colormap[i].blue); } /* Define SIXEL pixels. */ output = sixel_output_create(image); if (output == (sixel_output_t *) NULL) ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); sixel_pixels=(sixel_pixel_t *) AcquireQuantumMemory(image->columns, image->rows*sizeof(sixel_pixel_t)); if (sixel_pixels == (sixel_pixel_t *) NULL) { output=(sixel_output_t *) RelinquishMagickMemory(output); ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed"); } for (y=0; y < (ssize_t) image->rows; y++) { q=GetVirtualPixels(image,0,y,image->columns,1,exception); if (q == (Quantum *) NULL) break; for (x=0; x < (ssize_t) image->columns; x++) { sixel_pixels[y*image->columns+x]=((ssize_t) GetPixelIndex(image,q)); q+=GetPixelChannels(image); } } status=sixel_encode_impl(sixel_pixels,image->columns,image->rows, sixel_palette,image->colors,-1,output); sixel_pixels=(sixel_pixel_t *) RelinquishMagickMemory(sixel_pixels); output=(sixel_output_t *) RelinquishMagickMemory(output); (void) CloseBlob(image); return(status); }