granicus.if.org Git - imagemagick/blob - coders/sixel.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                     SSSSS  IIIII  X   X  EEEEE  L                           %
   7 %                     SS       I     X X   E      L                           %
   8 %                      SSS     I      X    EEE    L                           %
   9 %                        SS    I     X X   E      L                           %
  10 %                     SSSSS  IIIII  X   X  EEEEE  LLLLL                       %
  11 %                                                                             %
  12 %                                                                             %
  13 %                        Read/Write DEC SIXEL Format                          %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                               Hayaki Saito                                  %
  17 %                              September 2014                                 %
  18 %                    Based on kmiya's sixel (2014-03-28)                      %
  19 %                                                                             %
  20 %                                                                             %
  21 %  Copyright 1999-2017 ImageMagick Studio LLC, a non-profit organization      %
  22 %  dedicated to making software imaging solutions freely available.           %
  23 %                                                                             %
  24 %  You may not use this file except in compliance with the License.  You may  %
  25 %  obtain a copy of the License at                                            %
  26 %                                                                             %
  27 %    http://www.imagemagick.org/script/license.php                            %
  28 %                                                                             %
  29 %  Unless required by applicable law or agreed to in writing, software        %
  30 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  31 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  32 %  See the License for the specific language governing permissions and        %
  33 %  limitations under the License.                                             %
  34 %                                                                             %
  35 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  36 %
  37 %
  38 */
  39 \f
  40 /*
  41   Include declarations.
  42 */
  43 #include "MagickCore/studio.h"
  44 #include "MagickCore/attribute.h"
  45 #include "MagickCore/blob.h"
  46 #include "MagickCore/blob-private.h"
  47 #include "MagickCore/cache.h"
  48 #include "MagickCore/color.h"
  49 #include "MagickCore/color-private.h"
  50 #include "MagickCore/colormap.h"
  51 #include "MagickCore/colorspace.h"
  52 #include "MagickCore/colorspace-private.h"
  53 #include "MagickCore/exception.h"
  54 #include "MagickCore/exception-private.h"
  55 #include "MagickCore/geometry.h"
  56 #include "MagickCore/image.h"
  57 #include "MagickCore/image-private.h"
  58 #include "MagickCore/list.h"
  59 #include "MagickCore/magick.h"
  60 #include "MagickCore/memory_.h"
  61 #include "MagickCore/monitor.h"
  62 #include "MagickCore/monitor-private.h"
  63 #include "MagickCore/pixel-accessor.h"
  64 #include "MagickCore/pixel-private.h"
  65 #include "MagickCore/quantize.h"
  66 #include "MagickCore/quantum-private.h"
  67 #include "MagickCore/resize.h"
  68 #include "MagickCore/resource_.h"
  69 #include "MagickCore/splay-tree.h"
  70 #include "MagickCore/static.h"
  71 #include "MagickCore/string_.h"
  72 #include "MagickCore/thread-private.h"
  73 #include "MagickCore/module.h"
  74 #include "MagickCore/threshold.h"
  75 #include "MagickCore/utility.h"
  76
  77 /*
  78   Definitions
  79 */
  80 #define SIXEL_PALETTE_MAX 256
  81 #define SIXEL_OUTPUT_PACKET_SIZE 1024
  82
  83 /*
  84   Macros
  85 */
  86 #define SIXEL_RGB(r, g, b) (((r) << 16) + ((g) << 8) +  (b))
  87 #define SIXEL_PALVAL(n,a,m) (((n) * (a) + ((m) / 2)) / (m))
  88 #define SIXEL_XRGB(r,g,b) SIXEL_RGB(SIXEL_PALVAL(r, 255, 100), SIXEL_PALVAL(g, 255, 100), SIXEL_PALVAL(b, 255, 100))
  89
  90 /*
  91   Structure declarations.
  92 */
  93 typedef struct sixel_node {
  94     struct sixel_node *next;
  95     int color;
  96     int left;
  97     int right;
  98     unsigned char *map;
  99 } sixel_node_t;
 100
 101 typedef struct sixel_output {
 102
 103     /* compatiblity flags */
 104
 105     /* 0: 7bit terminal,
 106      * 1: 8bit terminal */
 107     unsigned char has_8bit_control;
 108
 109     int save_pixel;
 110     int save_count;
 111     int active_palette;
 112
 113     sixel_node_t *node_top;
 114     sixel_node_t *node_free;
 115
 116     Image *image;
 117     int pos;
 118     unsigned char buffer[1];
 119
 120 } sixel_output_t;
 121
 122 static int const sixel_default_color_table[] = {
 123     SIXEL_XRGB(0,  0,  0),   /*  0 Black    */
 124     SIXEL_XRGB(20, 20, 80),  /*  1 Blue     */
 125     SIXEL_XRGB(80, 13, 13),  /*  2 Red      */
 126     SIXEL_XRGB(20, 80, 20),  /*  3 Green    */
 127     SIXEL_XRGB(80, 20, 80),  /*  4 Magenta  */
 128     SIXEL_XRGB(20, 80, 80),  /*  5 Cyan     */
 129     SIXEL_XRGB(80, 80, 20),  /*  6 Yellow   */
 130     SIXEL_XRGB(53, 53, 53),  /*  7 Gray 50% */
 131     SIXEL_XRGB(26, 26, 26),  /*  8 Gray 25% */
 132     SIXEL_XRGB(33, 33, 60),  /*  9 Blue*    */
 133     SIXEL_XRGB(60, 26, 26),  /* 10 Red*     */
 134     SIXEL_XRGB(33, 60, 33),  /* 11 Green*   */
 135     SIXEL_XRGB(60, 33, 60),  /* 12 Magenta* */
 136     SIXEL_XRGB(33, 60, 60),  /* 13 Cyan*    */
 137     SIXEL_XRGB(60, 60, 33),  /* 14 Yellow*  */
 138     SIXEL_XRGB(80, 80, 80),  /* 15 Gray 75% */
 139 };
 140
 141 /*
 142   Forward declarations.
 143 */
 144 static MagickBooleanType
 145   WriteSIXELImage(const ImageInfo *,Image *,ExceptionInfo *);
 146 \f
 147 static int hue_to_rgb(int n1, int n2, int hue)
 148 {
 149     const int HLSMAX = 100;
 150
 151     if (hue < 0) {
 152         hue += HLSMAX;
 153     }
 154
 155     if (hue > HLSMAX) {
 156         hue -= HLSMAX;
 157     }
 158
 159     if (hue < (HLSMAX / 6)) {
 160         return (n1 + (((n2 - n1) * hue + (HLSMAX / 12)) / (HLSMAX / 6)));
 161     }
 162     if (hue < (HLSMAX / 2)) {
 163         return (n2);
 164     }
 165     if (hue < ((HLSMAX * 2) / 3)) {
 166         return (n1 + (((n2 - n1) * (((HLSMAX * 2) / 3) - hue) + (HLSMAX / 12))/(HLSMAX / 6)));
 167     }
 168     return (n1);
 169 }
 170
 171 static int hls_to_rgb(int hue, int lum, int sat)
 172 {
 173     int R, G, B;
 174     int Magic1, Magic2;
 175     const int RGBMAX = 255;
 176     const int HLSMAX = 100;
 177
 178     if (sat == 0) {
 179         R = G = B = (lum * RGBMAX) / HLSMAX;
 180     } else {
 181         if (lum <= (HLSMAX / 2)) {
 182             Magic2 = (lum * (HLSMAX + sat) + (HLSMAX / 2)) / HLSMAX;
 183         } else {
 184             Magic2 = lum + sat - ((lum * sat) + (HLSMAX / 2)) / HLSMAX;
 185         }
 186         Magic1 = 2 * lum - Magic2;
 187
 188         R = (hue_to_rgb(Magic1, Magic2, hue + (HLSMAX / 3)) * RGBMAX + (HLSMAX / 2)) / HLSMAX;
 189         G = (hue_to_rgb(Magic1, Magic2, hue) * RGBMAX + (HLSMAX / 2)) / HLSMAX;
 190         B = (hue_to_rgb(Magic1, Magic2, hue - (HLSMAX / 3)) * RGBMAX + (HLSMAX/2)) / HLSMAX;
 191     }
 192     return SIXEL_RGB(R, G, B);
 193 }
 194
 195 static unsigned char *get_params(unsigned char *p, int *param, int *len)
 196 {
 197     int n;
 198
 199     *len = 0;
 200     while (*p != '\0') {
 201         while (*p == ' ' || *p == '\t') {
 202             p++;
 203         }
 204         if (isdigit(*p)) {
 205             for (n = 0; isdigit(*p); p++) {
 206                 n = n * 10 + (*p - '0');
 207             }
 208             if (*len < 10) {
 209                 param[(*len)++] = n;
 210             }
 211             while (*p == ' ' || *p == '\t') {
 212                 p++;
 213             }
 214             if (*p == ';') {
 215                 p++;
 216             }
 217         } else if (*p == ';') {
 218             if (*len < 10) {
 219                 param[(*len)++] = 0;
 220             }
 221             p++;
 222         } else
 223             break;
 224     }
 225     return p;
 226 }
 227
 228 /* convert sixel data into indexed pixel bytes and palette data */
 229 MagickBooleanType sixel_decode(unsigned char              /* in */  *p,         /* sixel bytes */
 230                                unsigned char              /* out */ **pixels,   /* decoded pixels */
 231                                size_t                     /* out */ *pwidth,    /* image width */
 232                                size_t                     /* out */ *pheight,   /* image height */
 233                                unsigned char              /* out */ **palette,  /* ARGB palette */
 234                                size_t                     /* out */ *ncolors    /* palette size (<= 256) */)
 235 {
 236     int n, i, r, g, b, sixel_vertical_mask, c;
 237     int posision_x, posision_y;
 238     int max_x, max_y;
 239     int attributed_pan, attributed_pad;
 240     int attributed_ph, attributed_pv;
 241     int repeat_count, color_index, max_color_index = 2, background_color_index;
 242     int param[10];
 243     int sixel_palet[SIXEL_PALETTE_MAX];
 244     unsigned char *imbuf, *dmbuf;
 245     int imsx, imsy;
 246     int dmsx, dmsy;
 247     int y;
 248
 249     posision_x = posision_y = 0;
 250     max_x = max_y = 0;
 251     attributed_pan = 2;
 252     attributed_pad = 1;
 253     attributed_ph = attributed_pv = 0;
 254     repeat_count = 1;
 255     color_index = 0;
 256     background_color_index = 0;
 257
 258     imsx = 2048;
 259     imsy = 2048;
 260     imbuf = (unsigned char *) AcquireQuantumMemory(imsx , imsy);
 261
 262     if (imbuf == NULL) {
 263         return(MagickFalse);
 264     }
 265
 266     for (n = 0; n < 16; n++) {
 267         sixel_palet[n] = sixel_default_color_table[n];
 268     }
 269
 270     /* colors 16-231 are a 6x6x6 color cube */
 271     for (r = 0; r < 6; r++) {
 272         for (g = 0; g < 6; g++) {
 273             for (b = 0; b < 6; b++) {
 274                 sixel_palet[n++] = SIXEL_RGB(r * 51, g * 51, b * 51);
 275             }
 276         }
 277     }
 278     /* colors 232-255 are a grayscale ramp, intentionally leaving out */
 279     for (i = 0; i < 24; i++) {
 280         sixel_palet[n++] = SIXEL_RGB(i * 11, i * 11, i * 11);
 281     }
 282
 283     for (; n < SIXEL_PALETTE_MAX; n++) {
 284         sixel_palet[n] = SIXEL_RGB(255, 255, 255);
 285     }
 286
 287     (void) ResetMagickMemory(imbuf, background_color_index, (size_t) imsx * imsy);
 288
 289     while (*p != '\0') {
 290         if ((p[0] == '\033' && p[1] == 'P') || *p == 0x90) {
 291             if (*p == '\033') {
 292                 p++;
 293             }
 294
 295             p = get_params(++p, param, &n);
 296
 297             if (*p == 'q') {
 298                 p++;
 299
 300                 if (n > 0) {        /* Pn1 */
 301                     switch(param[0]) {
 302                     case 0:
 303                     case 1:
 304                         attributed_pad = 2;
 305                         break;
 306                     case 2:
 307                         attributed_pad = 5;
 308                         break;
 309                     case 3:
 310                         attributed_pad = 4;
 311                         break;
 312                     case 4:
 313                         attributed_pad = 4;
 314                         break;
 315                     case 5:
 316                         attributed_pad = 3;
 317                         break;
 318                     case 6:
 319                         attributed_pad = 3;
 320                         break;
 321                     case 7:
 322                         attributed_pad = 2;
 323                         break;
 324                     case 8:
 325                         attributed_pad = 2;
 326                         break;
 327                     case 9:
 328                         attributed_pad = 1;
 329                         break;
 330                     }
 331                 }
 332
 333                 if (n > 2) {        /* Pn3 */
 334                     if (param[2] == 0) {
 335                         param[2] = 10;
 336                     }
 337                     attributed_pan = attributed_pan * param[2] / 10;
 338                     attributed_pad = attributed_pad * param[2] / 10;
 339                     if (attributed_pan <= 0) attributed_pan = 1;
 340                     if (attributed_pad <= 0) attributed_pad = 1;
 341                 }
 342             }
 343
 344         } else if ((p[0] == '\033' && p[1] == '\\') || *p == 0x9C) {
 345             break;
 346         } else if (*p == '"') {
 347             /* DECGRA Set Raster Attributes " Pan; Pad; Ph; Pv */
 348             p = get_params(++p, param, &n);
 349
 350             if (n > 0) attributed_pad = param[0];
 351             if (n > 1) attributed_pan = param[1];
 352             if (n > 2 && param[2] > 0) attributed_ph = param[2];
 353             if (n > 3 && param[3] > 0) attributed_pv = param[3];
 354
 355             if (attributed_pan <= 0) attributed_pan = 1;
 356             if (attributed_pad <= 0) attributed_pad = 1;
 357
 358             if (imsx < attributed_ph || imsy < attributed_pv) {
 359                 dmsx = imsx > attributed_ph ? imsx : attributed_ph;
 360                 dmsy = imsy > attributed_pv ? imsy : attributed_pv;
 361                 dmbuf = (unsigned char *) AcquireQuantumMemory(dmsx , dmsy);
 362                 if (dmbuf == (unsigned char *) NULL) {
 363                     imbuf = (unsigned char *) RelinquishMagickMemory(imbuf);
 364                     return (MagickFalse);
 365                 }
 366                 (void) ResetMagickMemory(dmbuf, background_color_index, (size_t) dmsx * dmsy);
 367                 for (y = 0; y < imsy; ++y) {
 368                     (void) CopyMagickMemory(dmbuf + dmsx * y, imbuf + imsx * y, imsx);
 369                 }
 370                 imbuf = (unsigned char *) RelinquishMagickMemory(imbuf);
 371                 imsx = dmsx;
 372                 imsy = dmsy;
 373                 imbuf = dmbuf;
 374             }
 375
 376         } else if (*p == '!') {
 377             /* DECGRI Graphics Repeat Introducer ! Pn Ch */
 378             p = get_params(++p, param, &n);
 379
 380             if (n > 0) {
 381                 repeat_count = param[0];
 382             }
 383
 384         } else if (*p == '#') {
 385             /* DECGCI Graphics Color Introducer # Pc; Pu; Px; Py; Pz */
 386             p = get_params(++p, param, &n);
 387
 388             if (n > 0) {
 389                 if ((color_index = param[0]) < 0) {
 390                     color_index = 0;
 391                 } else if (color_index >= SIXEL_PALETTE_MAX) {
 392                     color_index = SIXEL_PALETTE_MAX - 1;
 393                 }
 394             }
 395
 396             if (n > 4) {
 397                 if (param[1] == 1) {            /* HLS */
 398                     if (param[2] > 360) param[2] = 360;
 399                     if (param[3] > 100) param[3] = 100;
 400                     if (param[4] > 100) param[4] = 100;
 401                     sixel_palet[color_index] = hls_to_rgb(param[2] * 100 / 360, param[3], param[4]);
 402                 } else if (param[1] == 2) {    /* RGB */
 403                     if (param[2] > 100) param[2] = 100;
 404                     if (param[3] > 100) param[3] = 100;
 405                     if (param[4] > 100) param[4] = 100;
 406                     sixel_palet[color_index] = SIXEL_XRGB(param[2], param[3], param[4]);
 407                 }
 408             }
 409
 410         } else if (*p == '$') {
 411             /* DECGCR Graphics Carriage Return */
 412             p++;
 413             posision_x = 0;
 414             repeat_count = 1;
 415
 416         } else if (*p == '-') {
 417             /* DECGNL Graphics Next Line */
 418             p++;
 419             posision_x  = 0;
 420             posision_y += 6;
 421             repeat_count = 1;
 422
 423         } else if (*p >= '?' && *p <= '\177') {
 424             if (imsx < (posision_x + repeat_count) || imsy < (posision_y + 6)) {
 425                 int nx = imsx * 2;
 426                 int ny = imsy * 2;
 427
 428                 while (nx < (posision_x + repeat_count) || ny < (posision_y + 6)) {
 429                     nx *= 2;
 430                     ny *= 2;
 431                 }
 432
 433                 dmsx = nx;
 434                 dmsy = ny;
 435                 dmbuf = (unsigned char *) AcquireQuantumMemory(dmsx , dmsy);
 436                 if (dmbuf == (unsigned char *) NULL) {
 437                     imbuf = (unsigned char *) RelinquishMagickMemory(imbuf);
 438                     return (MagickFalse);
 439                 }
 440                 (void) ResetMagickMemory(dmbuf, background_color_index, (size_t) dmsx * dmsy);
 441                 for (y = 0; y < imsy; ++y) {
 442                     (void) CopyMagickMemory(dmbuf + dmsx * y, imbuf + imsx * y, imsx);
 443                 }
 444                 imbuf = (unsigned char *) RelinquishMagickMemory(imbuf);
 445                 imsx = dmsx;
 446                 imsy = dmsy;
 447                 imbuf = dmbuf;
 448             }
 449
 450             if (color_index > max_color_index) {
 451                 max_color_index = color_index;
 452             }
 453             if ((b = *(p++) - '?') == 0) {
 454                 posision_x += repeat_count;
 455
 456             } else {
 457                 sixel_vertical_mask = 0x01;
 458
 459                 if (repeat_count <= 1) {
 460                     for (i = 0; i < 6; i++) {
 461                         if ((b & sixel_vertical_mask) != 0) {
 462                             imbuf[imsx * (posision_y + i) + posision_x] = color_index;
 463                             if (max_x < posision_x) {
 464                                 max_x = posision_x;
 465                             }
 466                             if (max_y < (posision_y + i)) {
 467                                 max_y = posision_y + i;
 468                             }
 469                         }
 470                         sixel_vertical_mask <<= 1;
 471                     }
 472                     posision_x += 1;
 473
 474                 } else { /* repeat_count > 1 */
 475                     for (i = 0; i < 6; i++) {
 476                         if ((b & sixel_vertical_mask) != 0) {
 477                             c = sixel_vertical_mask << 1;
 478                             for (n = 1; (i + n) < 6; n++) {
 479                                 if ((b & c) == 0) {
 480                                     break;
 481                                 }
 482                                 c <<= 1;
 483                             }
 484                             for (y = posision_y + i; y < posision_y + i + n; ++y) {
 485                                 (void) ResetMagickMemory(imbuf + (size_t) imsx * y + posision_x, color_index, repeat_count);
 486                             }
 487                             if (max_x < (posision_x + repeat_count - 1)) {
 488                                 max_x = posision_x + repeat_count - 1;
 489                             }
 490                             if (max_y < (posision_y + i + n - 1)) {
 491                                 max_y = posision_y + i + n - 1;
 492                             }
 493
 494                             i += (n - 1);
 495                             sixel_vertical_mask <<= (n - 1);
 496                         }
 497                         sixel_vertical_mask <<= 1;
 498                     }
 499                     posision_x += repeat_count;
 500                 }
 501             }
 502             repeat_count = 1;
 503         } else {
 504             p++;
 505         }
 506     }
 507
 508     if (++max_x < attributed_ph) {
 509         max_x = attributed_ph;
 510     }
 511     if (++max_y < attributed_pv) {
 512         max_y = attributed_pv;
 513     }
 514
 515     if (imsx > max_x || imsy > max_y) {
 516         dmsx = max_x;
 517         dmsy = max_y;
 518         if ((dmbuf = (unsigned char *) AcquireQuantumMemory(dmsx , dmsy)) == NULL) {
 519             imbuf = (unsigned char *) RelinquishMagickMemory(imbuf);
 520             return (MagickFalse);
 521         }
 522         for (y = 0; y < dmsy; ++y) {
 523             (void) CopyMagickMemory(dmbuf + dmsx * y, imbuf + imsx * y, dmsx);
 524         }
 525         imbuf = (unsigned char *) RelinquishMagickMemory(imbuf);
 526         imsx = dmsx;
 527         imsy = dmsy;
 528         imbuf = dmbuf;
 529     }
 530
 531     *pixels = imbuf;
 532     *pwidth = imsx;
 533     *pheight = imsy;
 534     *ncolors = max_color_index + 1;
 535     *palette = (unsigned char *) AcquireQuantumMemory(*ncolors,4);
 536     for (n = 0; n < (ssize_t) *ncolors; ++n) {
 537         (*palette)[n * 4 + 0] = sixel_palet[n] >> 16 & 0xff;
 538         (*palette)[n * 4 + 1] = sixel_palet[n] >> 8 & 0xff;
 539         (*palette)[n * 4 + 2] = sixel_palet[n] & 0xff;
 540         (*palette)[n * 4 + 3] = 0xff;
 541     }
 542     return(MagickTrue);
 543 }
 544
 545 sixel_output_t *sixel_output_create(Image *image)
 546 {
 547     sixel_output_t *output;
 548
 549     output = (sixel_output_t *) AcquireQuantumMemory(sizeof(sixel_output_t) + SIXEL_OUTPUT_PACKET_SIZE * 2, 1);
 550     output->has_8bit_control = 0;
 551     output->save_pixel = 0;
 552     output->save_count = 0;
 553     output->active_palette = (-1);
 554     output->node_top = NULL;
 555     output->node_free = NULL;
 556     output->image = image;
 557     output->pos = 0;
 558
 559     return output;
 560 }
 561
 562 static void sixel_advance(sixel_output_t *context, int nwrite)
 563 {
 564     if ((context->pos += nwrite) >= SIXEL_OUTPUT_PACKET_SIZE) {
 565         WriteBlob(context->image,SIXEL_OUTPUT_PACKET_SIZE,context->buffer);
 566         CopyMagickMemory(context->buffer,
 567                context->buffer + SIXEL_OUTPUT_PACKET_SIZE,
 568                (context->pos -= SIXEL_OUTPUT_PACKET_SIZE));
 569     }
 570 }
 571
 572 static int sixel_put_flash(sixel_output_t *const context)
 573 {
 574     int n;
 575     int nwrite;
 576
 577 #if defined(USE_VT240)        /* VT240 Max 255 ? */
 578     while (context->save_count > 255) {
 579         nwrite = spritf((char *)context->buffer + context->pos, "!255%c", context->save_pixel);
 580         if (nwrite <= 0) {
 581             return (-1);
 582         }
 583         sixel_advance(context, nwrite);
 584         context->save_count -= 255;
 585     }
 586 #endif  /* defined(USE_VT240) */
 587
 588     if (context->save_count > 3) {
 589         /* DECGRI Graphics Repeat Introducer ! Pn Ch */
 590         nwrite = sprintf((char *)context->buffer + context->pos, "!%d%c", context->save_count, context->save_pixel);
 591         if (nwrite <= 0) {
 592             return (-1);
 593         }
 594         sixel_advance(context, nwrite);
 595     } else {
 596         for (n = 0; n < context->save_count; n++) {
 597             context->buffer[context->pos] = (char)context->save_pixel;
 598             sixel_advance(context, 1);
 599         }
 600     }
 601
 602     context->save_pixel = 0;
 603     context->save_count = 0;
 604
 605     return 0;
 606 }
 607
 608 static void sixel_put_pixel(sixel_output_t *const context, int pix)
 609 {
 610     if (pix < 0 || pix > '?') {
 611         pix = 0;
 612     }
 613
 614     pix += '?';
 615
 616     if (pix == context->save_pixel) {
 617         context->save_count++;
 618     } else {
 619         sixel_put_flash(context);
 620         context->save_pixel = pix;
 621         context->save_count = 1;
 622     }
 623 }
 624
 625 static void sixel_node_del(sixel_output_t *const context, sixel_node_t *np)
 626 {
 627     sixel_node_t *tp;
 628
 629     if ((tp = context->node_top) == np) {
 630         context->node_top = np->next;
 631     }
 632
 633     else {
 634         while (tp->next != NULL) {
 635             if (tp->next == np) {
 636                 tp->next = np->next;
 637                 break;
 638             }
 639             tp = tp->next;
 640         }
 641     }
 642
 643     np->next = context->node_free;
 644     context->node_free = np;
 645 }
 646
 647 static int sixel_put_node(sixel_output_t *const context, int x,
 648                sixel_node_t *np, int ncolors, int keycolor)
 649 {
 650     int nwrite;
 651
 652     if (ncolors != 2 || keycolor == -1) {
 653         /* designate palette index */
 654         if (context->active_palette != np->color) {
 655             nwrite = sprintf((char *)context->buffer + context->pos,
 656                              "#%d", np->color);
 657             sixel_advance(context, nwrite);
 658             context->active_palette = np->color;
 659         }
 660     }
 661
 662     for (; x < np->left; x++) {
 663         sixel_put_pixel(context, 0);
 664     }
 665
 666     for (; x < np->right; x++) {
 667         sixel_put_pixel(context, np->map[x]);
 668     }
 669
 670     sixel_put_flash(context);
 671
 672     return x;
 673 }
 674
 675 static MagickBooleanType sixel_encode_impl(unsigned char *pixels, size_t width,size_t height,
 676                   unsigned char *palette, size_t ncolors, int keycolor,
 677                   sixel_output_t *context)
 678 {
 679 #define RelinquishNodesAndMap \
 680     while ((np = context->node_free) != NULL) { \
 681         context->node_free = np->next; \
 682         np=(sixel_node_t *) RelinquishMagickMemory(np); \
 683     } \
 684     map = (unsigned char *) RelinquishMagickMemory(map)
 685
 686     int x, y, i, n, c;
 687     int left, right;
 688     int pix;
 689     unsigned char *map;
 690     sixel_node_t *np, *tp, top;
 691     int nwrite;
 692     size_t len;
 693
 694     context->pos = 0;
 695
 696     if (ncolors < 1) {
 697         return (MagickFalse);
 698     }
 699     len = ncolors * width;
 700     context->active_palette = (-1);
 701
 702     if ((map = (unsigned char *)AcquireQuantumMemory(len, sizeof(unsigned char))) == NULL) {
 703         return (MagickFalse);
 704     }
 705     (void) ResetMagickMemory(map, 0, len);
 706
 707     if (context->has_8bit_control) {
 708         nwrite = sprintf((char *)context->buffer, "\x90" "0;0;0" "q");
 709     } else {
 710         nwrite = sprintf((char *)context->buffer, "\x1bP" "0;0;0" "q");
 711     }
 712     if (nwrite <= 0) {
 713         return (MagickFalse);
 714     }
 715     sixel_advance(context, nwrite);
 716     nwrite = sprintf((char *)context->buffer + context->pos, "\"1;1;%d;%d", (int) width, (int) height);
 717     if (nwrite <= 0) {
 718         RelinquishNodesAndMap;
 719         return (MagickFalse);
 720     }
 721     sixel_advance(context, nwrite);
 722
 723     if (ncolors != 2 || keycolor == -1) {
 724         for (n = 0; n < (ssize_t) ncolors; n++) {
 725             /* DECGCI Graphics Color Introducer  # Pc ; Pu; Px; Py; Pz */
 726             nwrite = sprintf((char *)context->buffer + context->pos, "#%d;2;%d;%d;%d",
 727                              n,
 728                              (palette[n * 3 + 0] * 100 + 127) / 255,
 729                              (palette[n * 3 + 1] * 100 + 127) / 255,
 730                              (palette[n * 3 + 2] * 100 + 127) / 255);
 731             if (nwrite <= 0) {
 732                 RelinquishNodesAndMap;
 733                 return (MagickFalse);
 734             }
 735             sixel_advance(context, nwrite);
 736             if (nwrite <= 0) {
 737                 RelinquishNodesAndMap;
 738                 return (MagickFalse);
 739             }
 740         }
 741     }
 742
 743     for (y = i = 0; y < (ssize_t) height; y++) {
 744         for (x = 0; x < (ssize_t) width; x++) {
 745             pix = pixels[y * width + x];
 746             if (pix >= 0 && pix < (ssize_t) ncolors && pix != keycolor) {
 747                 map[pix * width + x] |= (1 << i);
 748             }
 749         }
 750
 751         if (++i < 6 && (y + 1) < (ssize_t) height) {
 752             continue;
 753         }
 754
 755         for (c = 0; c < (ssize_t) ncolors; c++) {
 756             for (left = 0; left < (ssize_t) width; left++) {
 757                 if (*(map + c * width + left) == 0) {
 758                     continue;
 759                 }
 760
 761                 for (right = left + 1; right < (ssize_t) width; right++) {
 762                     if (*(map + c * width + right) != 0) {
 763                         continue;
 764                     }
 765
 766                     for (n = 1; (right + n) < (ssize_t) width; n++) {
 767                         if (*(map + c * width + right + n) != 0) {
 768                             break;
 769                         }
 770                     }
 771
 772                     if (n >= 10 || right + n >= (ssize_t) width) {
 773                         break;
 774                     }
 775                     right = right + n - 1;
 776                 }
 777
 778                 if ((np = context->node_free) != NULL) {
 779                     context->node_free = np->next;
 780                 } else if ((np = (sixel_node_t *)AcquireMagickMemory(sizeof(sixel_node_t))) == NULL) {
 781                     RelinquishNodesAndMap;
 782                     return (MagickFalse);
 783                 }
 784
 785                 np->color = c;
 786                 np->left = left;
 787                 np->right = right;
 788                 np->map = map + c * width;
 789
 790                 top.next = context->node_top;
 791                 tp = &top;
 792
 793                 while (tp->next != NULL) {
 794                     if (np->left < tp->next->left) {
 795                         break;
 796                     }
 797                     if (np->left == tp->next->left && np->right > tp->next->right) {
 798                         break;
 799                     }
 800                     tp = tp->next;
 801                 }
 802
 803                 np->next = tp->next;
 804                 tp->next = np;
 805                 context->node_top = top.next;
 806
 807                 left = right - 1;
 808             }
 809
 810         }
 811
 812         for (x = 0; (np = context->node_top) != NULL;) {
 813             if (x > np->left) {
 814                 /* DECGCR Graphics Carriage Return */
 815                 context->buffer[context->pos] = '$';
 816                 sixel_advance(context, 1);
 817                 x = 0;
 818             }
 819
 820             x = sixel_put_node(context, x, np, (int) ncolors, keycolor);
 821             sixel_node_del(context, np);
 822             np = context->node_top;
 823
 824             while (np != NULL) {
 825                 if (np->left < x) {
 826                     np = np->next;
 827                     continue;
 828                 }
 829
 830                 x = sixel_put_node(context, x, np, (int) ncolors, keycolor);
 831                 sixel_node_del(context, np);
 832                 np = context->node_top;
 833             }
 834         }
 835
 836         /* DECGNL Graphics Next Line */
 837         context->buffer[context->pos] = '-';
 838         sixel_advance(context, 1);
 839         if (nwrite <= 0) {
 840             RelinquishNodesAndMap;
 841             return (MagickFalse);
 842         }
 843
 844         i = 0;
 845         (void) ResetMagickMemory(map, 0, len);
 846     }
 847
 848     if (context->has_8bit_control) {
 849         context->buffer[context->pos] = 0x9c;
 850         sixel_advance(context, 1);
 851     } else {
 852         context->buffer[context->pos] = 0x1b;
 853         context->buffer[context->pos + 1] = '\\';
 854         sixel_advance(context, 2);
 855     }
 856     if (nwrite <= 0) {
 857         RelinquishNodesAndMap;
 858         return (MagickFalse);
 859     }
 860
 861     /* flush buffer */
 862     if (context->pos > 0) {
 863         WriteBlob(context->image,context->pos,context->buffer);
 864     }
 865
 866     RelinquishNodesAndMap;
 867
 868     return(MagickTrue);
 869 }
 870 \f
 871 /*
 872 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 873 %                                                                             %
 874 %                                                                             %
 875 %                                                                             %
 876 %   I s S I X E L                                                             %
 877 %                                                                             %
 878 %                                                                             %
 879 %                                                                             %
 880 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 881 %
 882 %  IsSIXEL() returns MagickTrue if the image format type, identified by the
 883 %  magick string, is SIXEL.
 884 %
 885 %  The format of the IsSIXEL method is:
 886 %
 887 %      MagickBooleanType IsSIXEL(const unsigned char *magick,
 888 %        const size_t length)
 889 %
 890 %  A description of each parameter follows:
 891 %
 892 %    o magick: compare image format pattern against these bytes. or
 893 %      blob.
 894 %
 895 %    o length: Specifies the length of the magick string.
 896 %
 897 */
 898 static MagickBooleanType IsSIXEL(const unsigned char *magick,
 899   const size_t length)
 900 {
 901   const unsigned char
 902     *end = magick + length;
 903
 904   if (length < 3)
 905     return(MagickFalse);
 906
 907   if (*magick == 0x90 || (*magick == 0x1b && *++magick == 'P')) {
 908     while (++magick != end) {
 909       if (*magick == 'q')
 910         return(MagickTrue);
 911       if (!(*magick >= '0' && *magick <= '9') && *magick != ';')
 912         return(MagickFalse);
 913     }
 914   }
 915   return(MagickFalse);
 916 }
 917 \f
 918 /*
 919 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 920 %                                                                             %
 921 %                                                                             %
 922 %                                                                             %
 923 %   R e a d S I X E L I m a g e                                               %
 924 %                                                                             %
 925 %                                                                             %
 926 %                                                                             %
 927 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 928 %
 929 %  ReadSIXELImage() reads an X11 pixmap image file and returns it.  It
 930 %  allocates the memory necessary for the new Image structure and returns a
 931 %  pointer to the new image.
 932 %
 933 %  The format of the ReadSIXELImage method is:
 934 %
 935 %      Image *ReadSIXELImage(const ImageInfo *image_info,
 936 %        ExceptionInfo *exception)
 937 %
 938 %  A description of each parameter follows:
 939 %
 940 %    o image_info: the image info.
 941 %
 942 %    o exception: return any errors or warnings in this structure.
 943 %
 944 */
 945 static Image *ReadSIXELImage(const ImageInfo *image_info,ExceptionInfo *exception)
 946 {
 947   char
 948     *sixel_buffer;
 949
 950   Image
 951     *image;
 952
 953   MagickBooleanType
 954     status;
 955
 956   register char
 957     *p;
 958
 959   register ssize_t
 960     x;
 961
 962   register Quantum
 963     *q;
 964
 965   size_t
 966     length;
 967
 968   ssize_t
 969     i,
 970     j,
 971     y;
 972
 973   unsigned char
 974     *sixel_pixels,
 975     *sixel_palette;
 976
 977   /*
 978     Open image file.
 979   */
 980   assert(image_info != (const ImageInfo *) NULL);
 981   assert(image_info->signature == MagickCoreSignature);
 982   if (image_info->debug != MagickFalse)
 983     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 984       image_info->filename);
 985   assert(exception != (ExceptionInfo *) NULL);
 986   assert(exception->signature == MagickCoreSignature);
 987   image=AcquireImage(image_info,exception);
 988   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 989   if (status == MagickFalse)
 990     {
 991       image=DestroyImageList(image);
 992       return((Image *) NULL);
 993     }
 994   /*
 995     Read SIXEL file.
 996   */
 997   length=MagickPathExtent;
 998   sixel_buffer=(char *) AcquireQuantumMemory((size_t) length,
 999     sizeof(*sixel_buffer));
1000   p=sixel_buffer;
1001   if (sixel_buffer != (char *) NULL)
1002     while (ReadBlobString(image,p) != (char *) NULL)
1003     {
1004       if ((*p == '#') && ((p == sixel_buffer) || (*(p-1) == '\n')))
1005         continue;
1006       if ((*p == '}') && (*(p+1) == ';'))
1007         break;
1008       p+=strlen(p);
1009       if ((size_t) (p-sixel_buffer+MagickPathExtent) < length)
1010         continue;
1011       length<<=1;
1012       sixel_buffer=(char *) ResizeQuantumMemory(sixel_buffer,length+
1013         MagickPathExtent,sizeof(*sixel_buffer));
1014       if (sixel_buffer == (char *) NULL)
1015         break;
1016       p=sixel_buffer+strlen(sixel_buffer);
1017     }
1018   if (sixel_buffer == (char *) NULL)
1019     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1020   /*
1021     Decode SIXEL
1022   */
1023   if (sixel_decode((unsigned char *) sixel_buffer,&sixel_pixels,&image->columns,&image->rows,&sixel_palette,&image->colors) == MagickFalse)
1024     {
1025       sixel_buffer=(char *) RelinquishMagickMemory(sixel_buffer);
1026       ThrowReaderException(CorruptImageError,"CorruptImage");
1027     }
1028   sixel_buffer=(char *) RelinquishMagickMemory(sixel_buffer);
1029   image->depth=24;
1030   image->storage_class=PseudoClass;
1031   status=SetImageExtent(image,image->columns,image->rows,exception);
1032   if (status == MagickFalse)
1033     return(DestroyImageList(image));
1034
1035   if (AcquireImageColormap(image,image->colors, exception) == MagickFalse)
1036     {
1037       sixel_pixels=(unsigned char *) RelinquishMagickMemory(sixel_pixels);
1038       sixel_palette=(unsigned char *) RelinquishMagickMemory(sixel_palette);
1039       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1040     }
1041   for (i = 0; i < (ssize_t) image->colors; ++i) {
1042     image->colormap[i].red   = ScaleCharToQuantum(sixel_palette[i * 4 + 0]);
1043     image->colormap[i].green = ScaleCharToQuantum(sixel_palette[i * 4 + 1]);
1044     image->colormap[i].blue  = ScaleCharToQuantum(sixel_palette[i * 4 + 2]);
1045   }
1046
1047   j=0;
1048   if (image_info->ping == MagickFalse)
1049     {
1050       /*
1051         Read image pixels.
1052       */
1053       for (y=0; y < (ssize_t) image->rows; y++)
1054       {
1055         q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
1056         if (q == (Quantum *) NULL)
1057           break;
1058         for (x=0; x < (ssize_t) image->columns; x++)
1059         {
1060           j=(ssize_t) sixel_pixels[y * image->columns + x];
1061           SetPixelIndex(image,j,q);
1062           q+=GetPixelChannels(image);
1063         }
1064         if (SyncAuthenticPixels(image,exception) == MagickFalse)
1065           break;
1066       }
1067       if (y < (ssize_t) image->rows)
1068         {
1069           sixel_pixels=(unsigned char *) RelinquishMagickMemory(sixel_pixels);
1070           sixel_palette=(unsigned char *) RelinquishMagickMemory(sixel_palette);
1071           ThrowReaderException(CorruptImageError,"NotEnoughPixelData");
1072         }
1073     }
1074   /*
1075     Relinquish resources.
1076   */
1077   sixel_pixels=(unsigned char *) RelinquishMagickMemory(sixel_pixels);
1078   sixel_palette=(unsigned char *) RelinquishMagickMemory(sixel_palette);
1079   (void) CloseBlob(image);
1080   return(GetFirstImageInList(image));
1081 }
1082 \f
1083 /*
1084 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1085 %                                                                             %
1086 %                                                                             %
1087 %                                                                             %
1088 %   R e g i s t e r S I X E L I m a g e                                       %
1089 %                                                                             %
1090 %                                                                             %
1091 %                                                                             %
1092 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1093 %
1094 %  RegisterSIXELImage() adds attributes for the SIXEL image format to
1095 %  the list of supported formats.  The attributes include the image format
1096 %  tag, a method to read and/or write the format, whether the format
1097 %  supports the saving of more than one frame to the same file or blob,
1098 %  whether the format supports native in-memory I/O, and a brief
1099 %  description of the format.
1100 %
1101 %  The format of the RegisterSIXELImage method is:
1102 %
1103 %      size_t RegisterSIXELImage(void)
1104 %
1105 */
1106 ModuleExport size_t RegisterSIXELImage(void)
1107 {
1108   MagickInfo
1109     *entry;
1110
1111   entry=AcquireMagickInfo("SIXEL","SIXEL","DEC SIXEL Graphics Format");
1112   entry->decoder=(DecodeImageHandler *) ReadSIXELImage;
1113   entry->encoder=(EncodeImageHandler *) WriteSIXELImage;
1114   entry->magick=(IsImageFormatHandler *) IsSIXEL;
1115   entry->flags^=CoderAdjoinFlag;
1116   (void) RegisterMagickInfo(entry);
1117   entry=AcquireMagickInfo("SIX","SIX","DEC SIXEL Graphics Format");
1118   entry->decoder=(DecodeImageHandler *) ReadSIXELImage;
1119   entry->encoder=(EncodeImageHandler *) WriteSIXELImage;
1120   entry->magick=(IsImageFormatHandler *) IsSIXEL;
1121   entry->flags^=CoderAdjoinFlag;
1122   (void) RegisterMagickInfo(entry);
1123   return(MagickImageCoderSignature);
1124 }
1125 \f
1126 /*
1127 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1128 %                                                                             %
1129 %                                                                             %
1130 %                                                                             %
1131 %   U n r e g i s t e r S I X E L I m a g e                                   %
1132 %                                                                             %
1133 %                                                                             %
1134 %                                                                             %
1135 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1136 %
1137 %  UnregisterSIXELImage() removes format registrations made by the
1138 %  SIXEL module from the list of supported formats.
1139 %
1140 %  The format of the UnregisterSIXELImage method is:
1141 %
1142 %      UnregisterSIXELImage(void)
1143 %
1144 */
1145 ModuleExport void UnregisterSIXELImage(void)
1146 {
1147   (void) UnregisterMagickInfo("SIXEL");
1148   (void) UnregisterMagickInfo("SIX");
1149 }
1150 \f
1151 /*
1152 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1153 %                                                                             %
1154 %                                                                             %
1155 %                                                                             %
1156 %   W r i t e S I X E L I m a g e                                             %
1157 %                                                                             %
1158 %                                                                             %
1159 %                                                                             %
1160 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1161 %
1162 %  WriteSIXELImage() writes an image to a file in the X pixmap format.
1163 %
1164 %  The format of the WriteSIXELImage method is:
1165 %
1166 %      MagickBooleanType WriteSIXELImage(const ImageInfo *image_info,
1167 %        Image *image,ExceptionInfo *exception)
1168 %
1169 %  A description of each parameter follows.
1170 %
1171 %    o image_info: the image info.
1172 %
1173 %    o image:  The image.
1174 %
1175 %    o exception: return any errors or warnings in this structure.
1176 %
1177 */
1178 static MagickBooleanType WriteSIXELImage(const ImageInfo *image_info,
1179   Image *image,ExceptionInfo *exception)
1180 {
1181   MagickBooleanType
1182     status;
1183
1184   register const Quantum
1185     *q;
1186
1187   register ssize_t
1188     i,
1189     x;
1190
1191   ssize_t
1192     opacity,
1193     y;
1194
1195   sixel_output_t
1196     *output;
1197
1198   unsigned char
1199     sixel_palette[256*3],
1200     *sixel_pixels;
1201
1202   /*
1203     Open output image file.
1204   */
1205   assert(image_info != (const ImageInfo *) NULL);
1206   assert(image_info->signature == MagickCoreSignature);
1207   assert(image != (Image *) NULL);
1208   assert(image->signature == MagickCoreSignature);
1209   if (image->debug != MagickFalse)
1210     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1211   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1212   if (status == MagickFalse)
1213     return(status);
1214   if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
1215     (void) TransformImageColorspace(image,sRGBColorspace,exception);
1216   opacity=(-1);
1217   if (image->alpha_trait == UndefinedPixelTrait)
1218     {
1219       if ((image->storage_class == DirectClass) || (image->colors > 256))
1220         (void) SetImageType(image,PaletteType,exception);
1221     }
1222   else
1223     {
1224       MagickRealType
1225         alpha,
1226         beta;
1227
1228       /*
1229         Identify transparent colormap index.
1230       */
1231       if ((image->storage_class == DirectClass) || (image->colors > 256))
1232         (void) SetImageType(image,PaletteBilevelAlphaType,exception);
1233       for (i=0; i < (ssize_t) image->colors; i++)
1234         if (image->colormap[i].alpha != OpaqueAlpha)
1235           {
1236             if (opacity < 0)
1237               {
1238                 opacity=i;
1239                 continue;
1240               }
1241             alpha=image->colormap[i].alpha;
1242             beta=image->colormap[opacity].alpha;
1243             if (alpha < beta)
1244               opacity=i;
1245           }
1246       if (opacity == -1)
1247         {
1248           (void) SetImageType(image,PaletteBilevelAlphaType,exception);
1249           for (i=0; i < (ssize_t) image->colors; i++)
1250             if (image->colormap[i].alpha != OpaqueAlpha)
1251               {
1252                 if (opacity < 0)
1253                   {
1254                     opacity=i;
1255                     continue;
1256                   }
1257                 alpha=image->colormap[i].alpha;
1258                 beta=image->colormap[opacity].alpha;
1259                 if (alpha < beta)
1260                   opacity=i;
1261               }
1262         }
1263       if (opacity >= 0)
1264         {
1265           image->colormap[opacity].red=image->transparent_color.red;
1266           image->colormap[opacity].green=image->transparent_color.green;
1267           image->colormap[opacity].blue=image->transparent_color.blue;
1268         }
1269     }
1270   /*
1271     SIXEL header.
1272   */
1273   for (i=0; i < (ssize_t) image->colors; i++)
1274   {
1275     sixel_palette[3*i+0]=ScaleQuantumToChar(image->colormap[i].red);
1276     sixel_palette[3*i+1]=ScaleQuantumToChar(image->colormap[i].green);
1277     sixel_palette[3*i+2]=ScaleQuantumToChar(image->colormap[i].blue);
1278   }
1279
1280   /*
1281     Define SIXEL pixels.
1282   */
1283   output = sixel_output_create(image);
1284   sixel_pixels=(unsigned char *) AcquireQuantumMemory(image->columns,
1285     image->rows*sizeof(*sixel_pixels));
1286   for (y=0; y < (ssize_t) image->rows; y++)
1287   {
1288     q=GetVirtualPixels(image,0,y,image->columns,1,exception);
1289     if (q == (Quantum *) NULL)
1290       break;
1291     for (x=0; x < (ssize_t) image->columns; x++)
1292       {
1293         sixel_pixels[y*image->columns+x]= ((ssize_t) GetPixelIndex(image,q));
1294         q+=GetPixelChannels(image);
1295       }
1296   }
1297   status = sixel_encode_impl(sixel_pixels,image->columns,image->rows,
1298     sixel_palette,image->colors,-1,output);
1299   sixel_pixels=(unsigned char *) RelinquishMagickMemory(sixel_pixels);
1300   output=(sixel_output_t *) RelinquishMagickMemory(output);
1301   (void) CloseBlob(image);
1302   return(status);
1303 }