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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                        IIIII   CCCC   OOO   N   N                           %
   7 %                          I    C      O   O  NN  N                           %
   8 %                          I    C      O   O  N N N                           %
   9 %                          I    C      O   O  N  NN                           %
  10 %                        IIIII   CCCC   OOO   N   N                           %
  11 %                                                                             %
  12 %                                                                             %
  13 %                   Read Microsoft Windows Icon Format                        %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                   Cristy                                    %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2017 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "MagickCore/studio.h"
  43 #include "MagickCore/artifact.h"
  44 #include "MagickCore/blob.h"
  45 #include "MagickCore/blob-private.h"
  46 #include "MagickCore/cache.h"
  47 #include "MagickCore/colormap.h"
  48 #include "MagickCore/colorspace.h"
  49 #include "MagickCore/colorspace-private.h"
  50 #include "MagickCore/exception.h"
  51 #include "MagickCore/exception-private.h"
  52 #include "MagickCore/image.h"
  53 #include "MagickCore/image-private.h"
  54 #include "MagickCore/list.h"
  55 #include "MagickCore/log.h"
  56 #include "MagickCore/magick.h"
  57 #include "MagickCore/memory_.h"
  58 #include "MagickCore/monitor.h"
  59 #include "MagickCore/monitor-private.h"
  60 #include "MagickCore/nt-base-private.h"
  61 #include "MagickCore/option.h"
  62 #include "MagickCore/pixel-accessor.h"
  63 #include "MagickCore/quantize.h"
  64 #include "MagickCore/quantum-private.h"
  65 #include "MagickCore/static.h"
  66 #include "MagickCore/string_.h"
  67 #include "MagickCore/module.h"
  68 \f
  69 /*
  70   Define declarations.
  71 */
  72 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__MINGW32__) || defined(__MINGW64__)
  73 #define BI_RGB  0
  74 #define BI_RLE8  1
  75 #define BI_BITFIELDS  3
  76 #endif
  77 #define MaxIcons  1024
  78 \f
  79 /*
  80   Typedef declarations.
  81 */
  82 typedef struct _IconEntry
  83 {
  84   unsigned char
  85     width,
  86     height,
  87     colors,
  88     reserved;
  89
  90   unsigned short int
  91     planes,
  92     bits_per_pixel;
  93
  94   size_t
  95     size,
  96     offset;
  97 } IconEntry;
  98
  99 typedef struct _IconFile
 100 {
 101   short
 102     reserved,
 103     resource_type,
 104     count;
 105
 106   IconEntry
 107     directory[MaxIcons];
 108 } IconFile;
 109
 110 typedef struct _IconInfo
 111 {
 112   size_t
 113     file_size,
 114     ba_offset,
 115     offset_bits,
 116     size;
 117
 118   ssize_t
 119     width,
 120     height;
 121
 122   unsigned short
 123     planes,
 124     bits_per_pixel;
 125
 126   size_t
 127     compression,
 128     image_size,
 129     x_pixels,
 130     y_pixels,
 131     number_colors,
 132     red_mask,
 133     green_mask,
 134     blue_mask,
 135     alpha_mask,
 136     colors_important;
 137
 138   ssize_t
 139     colorspace;
 140 } IconInfo;
 141 \f
 142 /*
 143   Forward declaractions.
 144 */
 145 static Image
 146   *AutoResizeImage(const Image *,const char *,MagickOffsetType *,
 147     ExceptionInfo *);
 148
 149 static MagickBooleanType
 150   WriteICONImage(const ImageInfo *,Image *,ExceptionInfo *);
 151
 152 Image *AutoResizeImage(const Image *image,const char *option,
 153   MagickOffsetType *count,ExceptionInfo *exception)
 154 {
 155   #define MAX_SIZES 16
 156
 157   char
 158     *q;
 159
 160   const char
 161     *p;
 162
 163   Image
 164     *resized,
 165     *images;
 166
 167   register ssize_t
 168     i;
 169
 170   size_t
 171     sizes[MAX_SIZES]={256,192,128,96,64,48,40,32,24,16};
 172
 173   images=NULL;
 174   *count=0;
 175   i=0;
 176   p=option;
 177   while (*p != '\0' && i < MAX_SIZES)
 178   {
 179     size_t
 180       size;
 181
 182     while ((isspace((int) ((unsigned char) *p)) != 0))
 183       p++;
 184
 185     size=(size_t)strtol(p,&q,10);
 186     if ((p == q) || (size < 16) || (size > 256))
 187       return((Image *) NULL);
 188
 189     p=q;
 190     sizes[i++]=size;
 191
 192     while ((isspace((int) ((unsigned char) *p)) != 0) || (*p == ','))
 193       p++;
 194   }
 195
 196   if (i==0)
 197     i=10;
 198   *count=i;
 199   for (i=0; i < *count; i++)
 200   {
 201     resized=ResizeImage(image,sizes[i],sizes[i],image->filter,exception);
 202     if (resized == (Image *) NULL)
 203       return(DestroyImageList(images));
 204
 205     if (images == (Image *) NULL)
 206       images=resized;
 207     else
 208       AppendImageToList(&images,resized);
 209   }
 210   return(images);
 211 }
 212 \f
 213 /*
 214 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 215 %                                                                             %
 216 %                                                                             %
 217 %                                                                             %
 218 %   R e a d I C O N I m a g e                                                 %
 219 %                                                                             %
 220 %                                                                             %
 221 %                                                                             %
 222 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 223 %
 224 %  ReadICONImage() reads a Microsoft icon image file and returns it.  It
 225 %  allocates the memory necessary for the new Image structure and returns a
 226 %  pointer to the new image.
 227 %
 228 %  The format of the ReadICONImage method is:
 229 %
 230 %      Image *ReadICONImage(const ImageInfo *image_info,
 231 %        ExceptionInfo *exception)
 232 %
 233 %  A description of each parameter follows:
 234 %
 235 %    o image_info: the image info.
 236 %
 237 %    o exception: return any errors or warnings in this structure.
 238 %
 239 */
 240 static Image *ReadICONImage(const ImageInfo *image_info,
 241   ExceptionInfo *exception)
 242 {
 243   IconFile
 244     icon_file;
 245
 246   IconInfo
 247     icon_info;
 248
 249   Image
 250     *image;
 251
 252   MagickBooleanType
 253     status;
 254
 255   MagickSizeType
 256     extent;
 257
 258   register ssize_t
 259     i,
 260     x;
 261
 262   register Quantum
 263     *q;
 264
 265   register unsigned char
 266     *p;
 267
 268   size_t
 269     bit,
 270     byte,
 271     bytes_per_line,
 272     one,
 273     scanline_pad;
 274
 275   ssize_t
 276     count,
 277     offset,
 278     y;
 279
 280   /*
 281     Open image file.
 282   */
 283   assert(image_info != (const ImageInfo *) NULL);
 284   assert(image_info->signature == MagickCoreSignature);
 285   (void) LogMagickEvent(CoderEvent,GetMagickModule(),"%s",image_info->filename);
 286   assert(exception != (ExceptionInfo *) NULL);
 287   assert(exception->signature == MagickCoreSignature);
 288   image=AcquireImage(image_info,exception);
 289   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 290   if (status == MagickFalse)
 291     {
 292       image=DestroyImageList(image);
 293       return((Image *) NULL);
 294     }
 295   icon_file.reserved=(short) ReadBlobLSBShort(image);
 296   icon_file.resource_type=(short) ReadBlobLSBShort(image);
 297   icon_file.count=(short) ReadBlobLSBShort(image);
 298   if ((icon_file.reserved != 0) ||
 299       ((icon_file.resource_type != 1) && (icon_file.resource_type != 2)) ||
 300       (icon_file.count > MaxIcons))
 301     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 302   extent=0;
 303   for (i=0; i < icon_file.count; i++)
 304   {
 305     icon_file.directory[i].width=(unsigned char) ReadBlobByte(image);
 306     icon_file.directory[i].height=(unsigned char) ReadBlobByte(image);
 307     icon_file.directory[i].colors=(unsigned char) ReadBlobByte(image);
 308     icon_file.directory[i].reserved=(unsigned char) ReadBlobByte(image);
 309     icon_file.directory[i].planes=(unsigned short) ReadBlobLSBShort(image);
 310     icon_file.directory[i].bits_per_pixel=(unsigned short)
 311       ReadBlobLSBShort(image);
 312     icon_file.directory[i].size=ReadBlobLSBLong(image);
 313     icon_file.directory[i].offset=ReadBlobLSBLong(image);
 314     if (EOFBlob(image) != MagickFalse)
 315       break;
 316     extent=MagickMax(extent,icon_file.directory[i].size);
 317   }
 318   if ((EOFBlob(image) != MagickFalse) || (extent > GetBlobSize(image)))
 319     ThrowReaderException(CorruptImageError,"UnexpectedEndOfFile");
 320   one=1;
 321   for (i=0; i < icon_file.count; i++)
 322   {
 323     /*
 324       Verify Icon identifier.
 325     */
 326     offset=(ssize_t) SeekBlob(image,(MagickOffsetType)
 327       icon_file.directory[i].offset,SEEK_SET);
 328     if (offset < 0)
 329       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 330     icon_info.size=ReadBlobLSBLong(image);
 331     icon_info.width=(unsigned char) ReadBlobLSBSignedLong(image);
 332     icon_info.height=(unsigned char) (ReadBlobLSBSignedLong(image)/2);
 333     icon_info.planes=ReadBlobLSBShort(image);
 334     icon_info.bits_per_pixel=ReadBlobLSBShort(image);
 335     if (EOFBlob(image) != MagickFalse)
 336       {
 337         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 338           image->filename);
 339         break;
 340       }
 341     if (((icon_info.planes == 18505) && (icon_info.bits_per_pixel == 21060)) ||
 342         (icon_info.size == 0x474e5089))
 343       {
 344         Image
 345           *icon_image;
 346
 347         ImageInfo
 348           *read_info;
 349
 350         size_t
 351           length;
 352
 353         unsigned char
 354           *png;
 355
 356         /*
 357           Icon image encoded as a compressed PNG image.
 358         */
 359         length=icon_file.directory[i].size;
 360         if ((length < 16) || (~length < 16))
 361           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 362         png=(unsigned char *) AcquireQuantumMemory(length+16,sizeof(*png));
 363         if (png == (unsigned char *) NULL)
 364           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 365         (void) CopyMagickMemory(png,"\211PNG\r\n\032\n\000\000\000\015",12);
 366         png[12]=(unsigned char) icon_info.planes;
 367         png[13]=(unsigned char) (icon_info.planes >> 8);
 368         png[14]=(unsigned char) icon_info.bits_per_pixel;
 369         png[15]=(unsigned char) (icon_info.bits_per_pixel >> 8);
 370         count=ReadBlob(image,length-16,png+16);
 371         icon_image=(Image *) NULL;
 372         if (count > 0)
 373           {
 374             read_info=CloneImageInfo(image_info);
 375             (void) CopyMagickString(read_info->magick,"PNG",MagickPathExtent);
 376             icon_image=BlobToImage(read_info,png,length+16,exception);
 377             read_info=DestroyImageInfo(read_info);
 378           }
 379         png=(unsigned char *) RelinquishMagickMemory(png);
 380         if (icon_image == (Image *) NULL)
 381           {
 382             if (count != (ssize_t) (length-16))
 383               ThrowReaderException(CorruptImageError,
 384                 "InsufficientImageDataInFile");
 385             image=DestroyImageList(image);
 386             return((Image *) NULL);
 387           }
 388         DestroyBlob(icon_image);
 389         icon_image->blob=ReferenceBlob(image->blob);
 390         ReplaceImageInList(&image,icon_image);
 391       }
 392     else
 393       {
 394         if (icon_info.bits_per_pixel > 32)
 395           ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 396         icon_info.compression=ReadBlobLSBLong(image);
 397         icon_info.image_size=ReadBlobLSBLong(image);
 398         icon_info.x_pixels=ReadBlobLSBLong(image);
 399         icon_info.y_pixels=ReadBlobLSBLong(image);
 400         icon_info.number_colors=ReadBlobLSBLong(image);
 401         icon_info.colors_important=ReadBlobLSBLong(image);
 402         image->alpha_trait=BlendPixelTrait;
 403         image->columns=(size_t) icon_file.directory[i].width;
 404         if ((ssize_t) image->columns > icon_info.width)
 405           image->columns=(size_t) icon_info.width;
 406         if (image->columns == 0)
 407           image->columns=256;
 408         image->rows=(size_t) icon_file.directory[i].height;
 409         if ((ssize_t) image->rows > icon_info.height)
 410           image->rows=(size_t) icon_info.height;
 411         if (image->rows == 0)
 412           image->rows=256;
 413         image->depth=icon_info.bits_per_pixel;
 414         if (image->debug != MagickFalse)
 415           {
 416             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 417               " scene    = %.20g",(double) i);
 418             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 419               "   size   = %.20g",(double) icon_info.size);
 420             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 421               "   width  = %.20g",(double) icon_file.directory[i].width);
 422             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 423               "   height = %.20g",(double) icon_file.directory[i].height);
 424             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 425               "   colors = %.20g",(double ) icon_info.number_colors);
 426             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 427               "   planes = %.20g",(double) icon_info.planes);
 428             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 429               "   bpp    = %.20g",(double) icon_info.bits_per_pixel);
 430           }
 431       if ((icon_info.number_colors != 0) || (icon_info.bits_per_pixel <= 16U))
 432         {
 433           image->storage_class=PseudoClass;
 434           image->colors=icon_info.number_colors;
 435           if (image->colors == 0)
 436             image->colors=one << icon_info.bits_per_pixel;
 437         }
 438       if (image->storage_class == PseudoClass)
 439         {
 440           register ssize_t
 441             i;
 442
 443           unsigned char
 444             *icon_colormap;
 445
 446           /*
 447             Read Icon raster colormap.
 448           */
 449           if (AcquireImageColormap(image,image->colors,exception) ==
 450               MagickFalse)
 451             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 452           icon_colormap=(unsigned char *) AcquireQuantumMemory((size_t)
 453             image->colors,4UL*sizeof(*icon_colormap));
 454           if (icon_colormap == (unsigned char *) NULL)
 455             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 456           count=ReadBlob(image,(size_t) (4*image->colors),icon_colormap);
 457           if (count != (ssize_t) (4*image->colors))
 458             ThrowReaderException(CorruptImageError,
 459               "InsufficientImageDataInFile");
 460           p=icon_colormap;
 461           for (i=0; i < (ssize_t) image->colors; i++)
 462           {
 463             image->colormap[i].blue=(Quantum) ScaleCharToQuantum(*p++);
 464             image->colormap[i].green=(Quantum) ScaleCharToQuantum(*p++);
 465             image->colormap[i].red=(Quantum) ScaleCharToQuantum(*p++);
 466             p++;
 467           }
 468           icon_colormap=(unsigned char *) RelinquishMagickMemory(icon_colormap);
 469         }
 470         /*
 471           Convert Icon raster image to pixel packets.
 472         */
 473         if ((image_info->ping != MagickFalse) &&
 474             (image_info->number_scenes != 0))
 475           if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 476             break;
 477         status=SetImageExtent(image,image->columns,image->rows,exception);
 478         if (status == MagickFalse)
 479           return(DestroyImageList(image));
 480         bytes_per_line=(((image->columns*icon_info.bits_per_pixel)+31) &
 481           ~31) >> 3;
 482         (void) bytes_per_line;
 483         scanline_pad=((((image->columns*icon_info.bits_per_pixel)+31) & ~31)-
 484           (image->columns*icon_info.bits_per_pixel)) >> 3;
 485         switch (icon_info.bits_per_pixel)
 486         {
 487           case 1:
 488           {
 489             /*
 490               Convert bitmap scanline.
 491             */
 492             for (y=(ssize_t) image->rows-1; y >= 0; y--)
 493             {
 494               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 495               if (q == (Quantum *) NULL)
 496                 break;
 497               for (x=0; x < (ssize_t) (image->columns-7); x+=8)
 498               {
 499                 byte=(size_t) ReadBlobByte(image);
 500                 for (bit=0; bit < 8; bit++)
 501                 {
 502                   SetPixelIndex(image,((byte & (0x80 >> bit)) != 0 ? 0x01 :
 503                     0x00),q);
 504                   q+=GetPixelChannels(image);
 505                 }
 506               }
 507               if ((image->columns % 8) != 0)
 508                 {
 509                   byte=(size_t) ReadBlobByte(image);
 510                   for (bit=0; bit < (image->columns % 8); bit++)
 511                   {
 512                     SetPixelIndex(image,((byte & (0x80 >> bit)) != 0 ? 0x01 :
 513                       0x00),q);
 514                     q+=GetPixelChannels(image);
 515                   }
 516                 }
 517               for (x=0; x < (ssize_t) scanline_pad; x++)
 518                 (void) ReadBlobByte(image);
 519               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 520                 break;
 521               if (image->previous == (Image *) NULL)
 522                 {
 523                   status=SetImageProgress(image,LoadImageTag,image->rows-y-1,
 524                     image->rows);
 525                   if (status == MagickFalse)
 526                     break;
 527                 }
 528             }
 529             break;
 530           }
 531           case 4:
 532           {
 533             /*
 534               Read 4-bit Icon scanline.
 535             */
 536             for (y=(ssize_t) image->rows-1; y >= 0; y--)
 537             {
 538               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 539               if (q == (Quantum *) NULL)
 540                 break;
 541               for (x=0; x < ((ssize_t) image->columns-1); x+=2)
 542               {
 543                 byte=(size_t) ReadBlobByte(image);
 544                 SetPixelIndex(image,((byte >> 4) & 0xf),q);
 545                 q+=GetPixelChannels(image);
 546                 SetPixelIndex(image,((byte) & 0xf),q);
 547                 q+=GetPixelChannels(image);
 548               }
 549               if ((image->columns % 2) != 0)
 550                 {
 551                   byte=(size_t) ReadBlobByte(image);
 552                   SetPixelIndex(image,((byte >> 4) & 0xf),q);
 553                   q+=GetPixelChannels(image);
 554                 }
 555               for (x=0; x < (ssize_t) scanline_pad; x++)
 556                 (void) ReadBlobByte(image);
 557               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 558                 break;
 559               if (image->previous == (Image *) NULL)
 560                 {
 561                   status=SetImageProgress(image,LoadImageTag,image->rows-y-1,
 562                     image->rows);
 563                   if (status == MagickFalse)
 564                     break;
 565                 }
 566             }
 567             break;
 568           }
 569           case 8:
 570           {
 571             /*
 572               Convert PseudoColor scanline.
 573             */
 574             for (y=(ssize_t) image->rows-1; y >= 0; y--)
 575             {
 576               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 577               if (q == (Quantum *) NULL)
 578                 break;
 579               for (x=0; x < (ssize_t) image->columns; x++)
 580               {
 581                 byte=(size_t) ReadBlobByte(image);
 582                 SetPixelIndex(image,(Quantum) byte,q);
 583                 q+=GetPixelChannels(image);
 584               }
 585               for (x=0; x < (ssize_t) scanline_pad; x++)
 586                 (void) ReadBlobByte(image);
 587               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 588                 break;
 589               if (image->previous == (Image *) NULL)
 590                 {
 591                   status=SetImageProgress(image,LoadImageTag,image->rows-y-1,
 592                     image->rows);
 593                   if (status == MagickFalse)
 594                     break;
 595                 }
 596             }
 597             break;
 598           }
 599           case 16:
 600           {
 601             /*
 602               Convert PseudoColor scanline.
 603             */
 604             for (y=(ssize_t) image->rows-1; y >= 0; y--)
 605             {
 606               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 607               if (q == (Quantum *) NULL)
 608                 break;
 609               for (x=0; x < (ssize_t) image->columns; x++)
 610               {
 611                 byte=(size_t) ReadBlobByte(image);
 612                 byte|=(size_t) (ReadBlobByte(image) << 8);
 613                 SetPixelIndex(image,(Quantum) byte,q);
 614                 q+=GetPixelChannels(image);
 615               }
 616               for (x=0; x < (ssize_t) scanline_pad; x++)
 617                 (void) ReadBlobByte(image);
 618               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 619                 break;
 620               if (image->previous == (Image *) NULL)
 621                 {
 622                   status=SetImageProgress(image,LoadImageTag,image->rows-y-1,
 623                     image->rows);
 624                   if (status == MagickFalse)
 625                     break;
 626                 }
 627             }
 628             break;
 629           }
 630           case 24:
 631           case 32:
 632           {
 633             /*
 634               Convert DirectColor scanline.
 635             */
 636             for (y=(ssize_t) image->rows-1; y >= 0; y--)
 637             {
 638               q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 639               if (q == (Quantum *) NULL)
 640                 break;
 641               for (x=0; x < (ssize_t) image->columns; x++)
 642               {
 643                 SetPixelBlue(image,ScaleCharToQuantum((unsigned char)
 644                   ReadBlobByte(image)),q);
 645                 SetPixelGreen(image,ScaleCharToQuantum((unsigned char)
 646                   ReadBlobByte(image)),q);
 647                 SetPixelRed(image,ScaleCharToQuantum((unsigned char)
 648                   ReadBlobByte(image)),q);
 649                 if (icon_info.bits_per_pixel == 32)
 650                   SetPixelAlpha(image,ScaleCharToQuantum((unsigned char)
 651                     ReadBlobByte(image)),q);
 652                 q+=GetPixelChannels(image);
 653               }
 654               if (icon_info.bits_per_pixel == 24)
 655                 for (x=0; x < (ssize_t) scanline_pad; x++)
 656                   (void) ReadBlobByte(image);
 657               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 658                 break;
 659               if (image->previous == (Image *) NULL)
 660                 {
 661                   status=SetImageProgress(image,LoadImageTag,image->rows-y-1,
 662                     image->rows);
 663                   if (status == MagickFalse)
 664                     break;
 665                 }
 666             }
 667             break;
 668           }
 669           default:
 670             ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 671         }
 672         if ((image_info->ping == MagickFalse) &&
 673             (icon_info.bits_per_pixel <= 16))
 674           (void) SyncImage(image,exception);
 675         if (icon_info.bits_per_pixel != 32)
 676           {
 677             /*
 678               Read the ICON alpha mask.
 679             */
 680             image->storage_class=DirectClass;
 681             for (y=(ssize_t) image->rows-1; y >= 0; y--)
 682             {
 683               q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
 684               if (q == (Quantum *) NULL)
 685                 break;
 686               for (x=0; x < ((ssize_t) image->columns-7); x+=8)
 687               {
 688                 byte=(size_t) ReadBlobByte(image);
 689                 for (bit=0; bit < 8; bit++)
 690                 {
 691                   SetPixelAlpha(image,(((byte & (0x80 >> bit)) != 0) ?
 692                     TransparentAlpha : OpaqueAlpha),q);
 693                   q+=GetPixelChannels(image);
 694                 }
 695               }
 696               if ((image->columns % 8) != 0)
 697                 {
 698                   byte=(size_t) ReadBlobByte(image);
 699                   for (bit=0; bit < (image->columns % 8); bit++)
 700                   {
 701                     SetPixelAlpha(image,(((byte & (0x80 >> bit)) != 0) ?
 702                       TransparentAlpha : OpaqueAlpha),q);
 703                     q+=GetPixelChannels(image);
 704                   }
 705                 }
 706               if ((image->columns % 32) != 0)
 707                 for (x=0; x < (ssize_t) ((32-(image->columns % 32))/8); x++)
 708                   (void) ReadBlobByte(image);
 709               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 710                 break;
 711             }
 712           }
 713         if (EOFBlob(image) != MagickFalse)
 714           {
 715             ThrowFileException(exception,CorruptImageError,
 716               "UnexpectedEndOfFile",image->filename);
 717             break;
 718           }
 719       }
 720     /*
 721       Proceed to next image.
 722     */
 723     if (image_info->number_scenes != 0)
 724       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 725         break;
 726     if (i < (ssize_t) (icon_file.count-1))
 727       {
 728         /*
 729           Allocate next image structure.
 730         */
 731         AcquireNextImage(image_info,image,exception);
 732         if (GetNextImageInList(image) == (Image *) NULL)
 733           {
 734             image=DestroyImageList(image);
 735             return((Image *) NULL);
 736           }
 737         image=SyncNextImageInList(image);
 738         status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
 739           GetBlobSize(image));
 740         if (status == MagickFalse)
 741           break;
 742       }
 743   }
 744   (void) CloseBlob(image);
 745   return(GetFirstImageInList(image));
 746 }
 747 \f
 748 /*
 749 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 750 %                                                                             %
 751 %                                                                             %
 752 %                                                                             %
 753 %   R e g i s t e r I C O N I m a g e                                         %
 754 %                                                                             %
 755 %                                                                             %
 756 %                                                                             %
 757 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 758 %
 759 %  RegisterICONImage() adds attributes for the Icon image format to
 760 %  the list of supported formats.  The attributes include the image format
 761 %  tag, a method to read and/or write the format, whether the format
 762 %  supports the saving of more than one frame to the same file or blob,
 763 %  whether the format supports native in-memory I/O, and a brief
 764 %  description of the format.
 765 %
 766 %  The format of the RegisterICONImage method is:
 767 %
 768 %      size_t RegisterICONImage(void)
 769 %
 770 */
 771 ModuleExport size_t RegisterICONImage(void)
 772 {
 773   MagickInfo
 774     *entry;
 775
 776   entry=AcquireMagickInfo("ICON","CUR","Microsoft icon");
 777   entry->decoder=(DecodeImageHandler *) ReadICONImage;
 778   entry->encoder=(EncodeImageHandler *) WriteICONImage;
 779   entry->flags^=CoderAdjoinFlag;
 780   entry->flags|=CoderDecoderSeekableStreamFlag;
 781   entry->flags|=CoderEncoderSeekableStreamFlag;
 782   (void) RegisterMagickInfo(entry);
 783   entry=AcquireMagickInfo("ICON","ICO","Microsoft icon");
 784   entry->decoder=(DecodeImageHandler *) ReadICONImage;
 785   entry->encoder=(EncodeImageHandler *) WriteICONImage;
 786   entry->flags|=CoderDecoderSeekableStreamFlag;
 787   entry->flags|=CoderEncoderSeekableStreamFlag;
 788   (void) RegisterMagickInfo(entry);
 789   entry=AcquireMagickInfo("ICON","ICON","Microsoft icon");
 790   entry->decoder=(DecodeImageHandler *) ReadICONImage;
 791   entry->encoder=(EncodeImageHandler *) WriteICONImage;
 792   entry->flags^=CoderAdjoinFlag;
 793   entry->flags|=CoderDecoderSeekableStreamFlag;
 794   entry->flags|=CoderEncoderSeekableStreamFlag;
 795   (void) RegisterMagickInfo(entry);
 796   return(MagickImageCoderSignature);
 797 }
 798 \f
 799 /*
 800 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 801 %                                                                             %
 802 %                                                                             %
 803 %                                                                             %
 804 %   U n r e g i s t e r I C O N I m a g e                                     %
 805 %                                                                             %
 806 %                                                                             %
 807 %                                                                             %
 808 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 809 %
 810 %  UnregisterICONImage() removes format registrations made by the
 811 %  ICON module from the list of supported formats.
 812 %
 813 %  The format of the UnregisterICONImage method is:
 814 %
 815 %      UnregisterICONImage(void)
 816 %
 817 */
 818 ModuleExport void UnregisterICONImage(void)
 819 {
 820   (void) UnregisterMagickInfo("CUR");
 821   (void) UnregisterMagickInfo("ICO");
 822   (void) UnregisterMagickInfo("ICON");
 823 }
 824 \f
 825 /*
 826 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 827 %                                                                             %
 828 %                                                                             %
 829 %                                                                             %
 830 %   W r i t e I C O N I m a g e                                               %
 831 %                                                                             %
 832 %                                                                             %
 833 %                                                                             %
 834 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 835 %
 836 %  WriteICONImage() writes an image in Microsoft Windows bitmap encoded
 837 %  image format, version 3 for Windows or (if the image has a matte channel)
 838 %  version 4.
 839 %
 840 %  It encodes any subimage as a compressed PNG image ("BI_PNG)", only when its
 841 %  dimensions are 256x256 and image->compression is undefined or is defined as
 842 %  ZipCompression.
 843 %
 844 %  The format of the WriteICONImage method is:
 845 %
 846 %      MagickBooleanType WriteICONImage(const ImageInfo *image_info,
 847 %        Image *image,ExceptionInfo *exception)
 848 %
 849 %  A description of each parameter follows.
 850 %
 851 %    o image_info: the image info.
 852 %
 853 %    o image:  The image.
 854 %
 855 %    o exception: return any errors or warnings in this structure.
 856 %
 857 */
 858 static MagickBooleanType WriteICONImage(const ImageInfo *image_info,
 859   Image *image,ExceptionInfo *exception)
 860 {
 861   const char
 862     *option;
 863
 864   IconFile
 865     icon_file;
 866
 867   IconInfo
 868     icon_info;
 869
 870   Image
 871     *images,
 872     *next;
 873
 874   MagickBooleanType
 875     status;
 876
 877   MagickOffsetType
 878     offset,
 879     scene;
 880
 881   register const Quantum
 882     *p;
 883
 884   register ssize_t
 885     i,
 886     x;
 887
 888   register unsigned char
 889     *q;
 890
 891   size_t
 892     bytes_per_line,
 893     scanline_pad;
 894
 895   ssize_t
 896     y;
 897
 898   unsigned char
 899     bit,
 900     byte,
 901     *pixels;
 902
 903   /*
 904     Open output image file.
 905   */
 906   assert(image_info != (const ImageInfo *) NULL);
 907   assert(image_info->signature == MagickCoreSignature);
 908   assert(image != (Image *) NULL);
 909   assert(image->signature == MagickCoreSignature);
 910     (void) LogMagickEvent(CoderEvent,GetMagickModule(),"%s",image->filename);
 911   assert(exception != (ExceptionInfo *) NULL);
 912   assert(exception->signature == MagickCoreSignature);
 913   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
 914   if (status == MagickFalse)
 915     return(status);
 916   images=(Image *) NULL;
 917   option=GetImageOption(image_info,"icon:auto-resize");
 918   if (option != (const char *) NULL)
 919     {
 920       images=AutoResizeImage(image,option,&scene,exception);
 921       if (images == (Image *) NULL)
 922         ThrowWriterException(ImageError,"InvalidDimensions");
 923     }
 924   else
 925     {
 926       scene=0;
 927       next=image;
 928       do
 929       {
 930         if ((image->columns > 256L) || (image->rows > 256L))
 931           ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
 932         scene++;
 933         next=SyncNextImageInList(next);
 934       } while ((next != (Image *) NULL) && (image_info->adjoin != MagickFalse));
 935     }
 936   /*
 937     Dump out a ICON header template to be properly initialized later.
 938   */
 939   (void) WriteBlobLSBShort(image,0);
 940   (void) WriteBlobLSBShort(image,1);
 941   (void) WriteBlobLSBShort(image,(unsigned char) scene);
 942   (void) ResetMagickMemory(&icon_file,0,sizeof(icon_file));
 943   (void) ResetMagickMemory(&icon_info,0,sizeof(icon_info));
 944   scene=0;
 945   next=(images != (Image *) NULL) ? images : image;
 946   do
 947   {
 948     (void) WriteBlobByte(image,icon_file.directory[scene].width);
 949     (void) WriteBlobByte(image,icon_file.directory[scene].height);
 950     (void) WriteBlobByte(image,icon_file.directory[scene].colors);
 951     (void) WriteBlobByte(image,icon_file.directory[scene].reserved);
 952     (void) WriteBlobLSBShort(image,icon_file.directory[scene].planes);
 953     (void) WriteBlobLSBShort(image,icon_file.directory[scene].bits_per_pixel);
 954     (void) WriteBlobLSBLong(image,(unsigned int)
 955       icon_file.directory[scene].size);
 956     (void) WriteBlobLSBLong(image,(unsigned int)
 957       icon_file.directory[scene].offset);
 958     scene++;
 959     next=SyncNextImageInList(next);
 960   } while ((next != (Image *) NULL) && (image_info->adjoin != MagickFalse));
 961   scene=0;
 962   next=(images != (Image *) NULL) ? images : image;
 963   do
 964   {
 965     if ((next->columns > 255L) && (next->rows > 255L) &&
 966         ((next->compression == UndefinedCompression) ||
 967         (next->compression == ZipCompression)))
 968       {
 969         Image
 970           *write_image;
 971
 972         ImageInfo
 973           *write_info;
 974
 975         size_t
 976           length;
 977
 978         unsigned char
 979           *png;
 980
 981         write_image=CloneImage(next,0,0,MagickTrue,exception);
 982         if (write_image == (Image *) NULL)
 983           {
 984             images=DestroyImageList(images);
 985             return(MagickFalse);
 986           }
 987         write_info=CloneImageInfo(image_info);
 988         (void) CopyMagickString(write_info->filename,"PNG:",MagickPathExtent);
 989
 990         /* Don't write any ancillary chunks except for gAMA */
 991         (void) SetImageArtifact(write_image,"png:include-chunk","none,gama");
 992
 993         /* Only write PNG32 formatted PNG (32-bit RGBA), 8 bits per channel */
 994         (void) SetImageArtifact(write_image,"png:format","png32");
 995
 996         png=(unsigned char *) ImageToBlob(write_info,write_image,&length,
 997           exception);
 998         write_image=DestroyImageList(write_image);
 999         write_info=DestroyImageInfo(write_info);
1000         if (png == (unsigned char *) NULL)
1001           {
1002             images=DestroyImageList(images);
1003             return(MagickFalse);
1004           }
1005         icon_file.directory[scene].width=0;
1006         icon_file.directory[scene].height=0;
1007         icon_file.directory[scene].colors=0;
1008         icon_file.directory[scene].reserved=0;
1009         icon_file.directory[scene].planes=1;
1010         icon_file.directory[scene].bits_per_pixel=32;
1011         icon_file.directory[scene].size=(size_t) length;
1012         icon_file.directory[scene].offset=(size_t) TellBlob(image);
1013         (void) WriteBlob(image,(size_t) length,png);
1014         png=(unsigned char *) RelinquishMagickMemory(png);
1015       }
1016     else
1017       {
1018         /*
1019           Initialize ICON raster file header.
1020         */
1021         (void) TransformImageColorspace(next,sRGBColorspace,exception);
1022         icon_info.file_size=14+12+28;
1023         icon_info.offset_bits=icon_info.file_size;
1024         icon_info.compression=BI_RGB;
1025         if ((next->storage_class != DirectClass) && (next->colors > 256))
1026           (void) SetImageStorageClass(next,DirectClass,exception);
1027         if (next->storage_class == DirectClass)
1028           {
1029             /*
1030               Full color ICON raster.
1031             */
1032             icon_info.number_colors=0;
1033             icon_info.bits_per_pixel=32;
1034             icon_info.compression=(size_t) BI_RGB;
1035           }
1036         else
1037           {
1038             size_t
1039               one;
1040
1041             /*
1042               Colormapped ICON raster.
1043             */
1044             icon_info.bits_per_pixel=8;
1045             if (next->colors <= 256)
1046               icon_info.bits_per_pixel=8;
1047             if (next->colors <= 16)
1048               icon_info.bits_per_pixel=4;
1049             if (next->colors <= 2)
1050               icon_info.bits_per_pixel=1;
1051             one=1;
1052             icon_info.number_colors=one << icon_info.bits_per_pixel;
1053             if (icon_info.number_colors < next->colors)
1054               {
1055                 (void) SetImageStorageClass(next,DirectClass,exception);
1056                 icon_info.number_colors=0;
1057                 icon_info.bits_per_pixel=(unsigned short) 24;
1058                 icon_info.compression=(size_t) BI_RGB;
1059               }
1060             else
1061               {
1062                 size_t
1063                   one;
1064
1065                 one=1;
1066                 icon_info.file_size+=3*(one << icon_info.bits_per_pixel);
1067                 icon_info.offset_bits+=3*(one << icon_info.bits_per_pixel);
1068                 icon_info.file_size+=(one << icon_info.bits_per_pixel);
1069                 icon_info.offset_bits+=(one << icon_info.bits_per_pixel);
1070               }
1071           }
1072         bytes_per_line=(((next->columns*icon_info.bits_per_pixel)+31) &
1073           ~31) >> 3;
1074         icon_info.ba_offset=0;
1075         icon_info.width=(ssize_t) next->columns;
1076         icon_info.height=(ssize_t) next->rows;
1077         icon_info.planes=1;
1078         icon_info.image_size=bytes_per_line*next->rows;
1079         icon_info.size=40;
1080         icon_info.size+=(4*icon_info.number_colors);
1081         icon_info.size+=icon_info.image_size;
1082         icon_info.size+=(((icon_info.width+31) & ~31) >> 3)*icon_info.height;
1083         icon_info.file_size+=icon_info.image_size;
1084         icon_info.x_pixels=0;
1085         icon_info.y_pixels=0;
1086         switch (next->units)
1087         {
1088           case UndefinedResolution:
1089           case PixelsPerInchResolution:
1090           {
1091             icon_info.x_pixels=(size_t) (100.0*next->resolution.x/2.54);
1092             icon_info.y_pixels=(size_t) (100.0*next->resolution.y/2.54);
1093             break;
1094           }
1095           case PixelsPerCentimeterResolution:
1096           {
1097             icon_info.x_pixels=(size_t) (100.0*next->resolution.x);
1098             icon_info.y_pixels=(size_t) (100.0*next->resolution.y);
1099             break;
1100           }
1101         }
1102         icon_info.colors_important=icon_info.number_colors;
1103         /*
1104           Convert MIFF to ICON raster pixels.
1105         */
1106         pixels=(unsigned char *) AcquireQuantumMemory((size_t)
1107           icon_info.image_size,sizeof(*pixels));
1108         if (pixels == (unsigned char *) NULL)
1109           {
1110             images=DestroyImageList(images);
1111             ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1112           }
1113         (void) ResetMagickMemory(pixels,0,(size_t) icon_info.image_size);
1114         switch (icon_info.bits_per_pixel)
1115         {
1116           case 1:
1117           {
1118             size_t
1119               bit,
1120               byte;
1121
1122             /*
1123               Convert PseudoClass image to a ICON monochrome image.
1124             */
1125             for (y=0; y < (ssize_t) next->rows; y++)
1126             {
1127               p=GetVirtualPixels(next,0,y,next->columns,1,exception);
1128               if (p == (const Quantum *) NULL)
1129                 break;
1130               q=pixels+(next->rows-y-1)*bytes_per_line;
1131               bit=0;
1132               byte=0;
1133               for (x=0; x < (ssize_t) next->columns; x++)
1134               {
1135                 byte<<=1;
1136                 byte|=GetPixelIndex(next,p) != 0 ? 0x01 : 0x00;
1137                 bit++;
1138                 if (bit == 8)
1139                   {
1140                     *q++=(unsigned char) byte;
1141                     bit=0;
1142                     byte=0;
1143                   }
1144                 p+=GetPixelChannels(image);
1145               }
1146               if (bit != 0)
1147                 *q++=(unsigned char) (byte << (8-bit));
1148               if (next->previous == (Image *) NULL)
1149                 {
1150                   status=SetImageProgress(next,SaveImageTag,y,next->rows);
1151                   if (status == MagickFalse)
1152                     break;
1153                 }
1154             }
1155             break;
1156           }
1157           case 4:
1158           {
1159             size_t
1160               nibble,
1161               byte;
1162
1163             /*
1164               Convert PseudoClass image to a ICON monochrome image.
1165             */
1166             for (y=0; y < (ssize_t) next->rows; y++)
1167             {
1168               p=GetVirtualPixels(next,0,y,next->columns,1,exception);
1169               if (p == (const Quantum *) NULL)
1170                 break;
1171               q=pixels+(next->rows-y-1)*bytes_per_line;
1172               nibble=0;
1173               byte=0;
1174               for (x=0; x < (ssize_t) next->columns; x++)
1175               {
1176                 byte<<=4;
1177                 byte|=((size_t) GetPixelIndex(next,p) & 0x0f);
1178                 nibble++;
1179                 if (nibble == 2)
1180                   {
1181                     *q++=(unsigned char) byte;
1182                     nibble=0;
1183                     byte=0;
1184                   }
1185                 p+=GetPixelChannels(image);
1186               }
1187               if (nibble != 0)
1188                 *q++=(unsigned char) (byte << 4);
1189               if (next->previous == (Image *) NULL)
1190                 {
1191                   status=SetImageProgress(next,SaveImageTag,y,next->rows);
1192                   if (status == MagickFalse)
1193                     break;
1194                 }
1195             }
1196             break;
1197           }
1198           case 8:
1199           {
1200             /*
1201               Convert PseudoClass packet to ICON pixel.
1202             */
1203             for (y=0; y < (ssize_t) next->rows; y++)
1204             {
1205               p=GetVirtualPixels(next,0,y,next->columns,1,exception);
1206               if (p == (const Quantum *) NULL)
1207                 break;
1208               q=pixels+(next->rows-y-1)*bytes_per_line;
1209               for (x=0; x < (ssize_t) next->columns; x++)
1210               {
1211                 *q++=(unsigned char) GetPixelIndex(next,p);
1212                 p+=GetPixelChannels(image);
1213               }
1214               if (next->previous == (Image *) NULL)
1215                 {
1216                   status=SetImageProgress(next,SaveImageTag,y,next->rows);
1217                   if (status == MagickFalse)
1218                     break;
1219                 }
1220             }
1221             break;
1222           }
1223           case 24:
1224           case 32:
1225           {
1226             /*
1227               Convert DirectClass packet to ICON BGR888 or BGRA8888 pixel.
1228             */
1229             for (y=0; y < (ssize_t) next->rows; y++)
1230             {
1231               p=GetVirtualPixels(next,0,y,next->columns,1,exception);
1232               if (p == (const Quantum *) NULL)
1233                 break;
1234               q=pixels+(next->rows-y-1)*bytes_per_line;
1235               for (x=0; x < (ssize_t) next->columns; x++)
1236               {
1237                 *q++=ScaleQuantumToChar(GetPixelBlue(next,p));
1238                 *q++=ScaleQuantumToChar(GetPixelGreen(next,p));
1239                 *q++=ScaleQuantumToChar(GetPixelRed(next,p));
1240                 if (next->alpha_trait == UndefinedPixelTrait)
1241                   *q++=ScaleQuantumToChar(QuantumRange);
1242                 else
1243                   *q++=ScaleQuantumToChar(GetPixelAlpha(next,p));
1244                 p+=GetPixelChannels(next);
1245               }
1246               if (icon_info.bits_per_pixel == 24)
1247                 for (x=3L*(ssize_t) next->columns; x < (ssize_t) bytes_per_line; x++)
1248                   *q++=0x00;
1249               if (next->previous == (Image *) NULL)
1250                 {
1251                   status=SetImageProgress(next,SaveImageTag,y,next->rows);
1252                   if (status == MagickFalse)
1253                     break;
1254                 }
1255             }
1256             break;
1257           }
1258         }
1259         /*
1260           Write 40-byte version 3+ bitmap header.
1261         */
1262         icon_file.directory[scene].width=(unsigned char) icon_info.width;
1263         icon_file.directory[scene].height=(unsigned char) icon_info.height;
1264         icon_file.directory[scene].colors=(unsigned char)
1265           icon_info.number_colors;
1266         icon_file.directory[scene].reserved=0;
1267         icon_file.directory[scene].planes=icon_info.planes;
1268         icon_file.directory[scene].bits_per_pixel=icon_info.bits_per_pixel;
1269         icon_file.directory[scene].size=icon_info.size;
1270         icon_file.directory[scene].offset=(size_t) TellBlob(image);
1271         (void) WriteBlobLSBLong(image,(unsigned int) 40);
1272         (void) WriteBlobLSBLong(image,(unsigned int) icon_info.width);
1273         (void) WriteBlobLSBLong(image,(unsigned int) icon_info.height*2);
1274         (void) WriteBlobLSBShort(image,icon_info.planes);
1275         (void) WriteBlobLSBShort(image,icon_info.bits_per_pixel);
1276         (void) WriteBlobLSBLong(image,(unsigned int) icon_info.compression);
1277         (void) WriteBlobLSBLong(image,(unsigned int) icon_info.image_size);
1278         (void) WriteBlobLSBLong(image,(unsigned int) icon_info.x_pixels);
1279         (void) WriteBlobLSBLong(image,(unsigned int) icon_info.y_pixels);
1280         (void) WriteBlobLSBLong(image,(unsigned int) icon_info.number_colors);
1281         (void) WriteBlobLSBLong(image,(unsigned int) icon_info.colors_important);
1282         if (next->storage_class == PseudoClass)
1283           {
1284             unsigned char
1285               *icon_colormap;
1286
1287             /*
1288               Dump colormap to file.
1289             */
1290             icon_colormap=(unsigned char *) AcquireQuantumMemory((size_t)
1291               (1UL << icon_info.bits_per_pixel),4UL*sizeof(*icon_colormap));
1292             if (icon_colormap == (unsigned char *) NULL)
1293               {
1294                 images=DestroyImageList(images);
1295                 ThrowWriterException(ResourceLimitError,
1296                   "MemoryAllocationFailed");
1297               }
1298             q=icon_colormap;
1299             for (i=0; i < (ssize_t) next->colors; i++)
1300             {
1301               *q++=ScaleQuantumToChar(next->colormap[i].blue);
1302               *q++=ScaleQuantumToChar(next->colormap[i].green);
1303               *q++=ScaleQuantumToChar(next->colormap[i].red);
1304               *q++=(unsigned char) 0x0;
1305             }
1306             for ( ; i < (ssize_t) (1UL << icon_info.bits_per_pixel); i++)
1307             {
1308               *q++=(unsigned char) 0x00;
1309               *q++=(unsigned char) 0x00;
1310               *q++=(unsigned char) 0x00;
1311               *q++=(unsigned char) 0x00;
1312             }
1313             (void) WriteBlob(image,(size_t) (4UL*(1UL <<
1314               icon_info.bits_per_pixel)),icon_colormap);
1315             icon_colormap=(unsigned char *) RelinquishMagickMemory(
1316               icon_colormap);
1317           }
1318         (void) WriteBlob(image,(size_t) icon_info.image_size,pixels);
1319         pixels=(unsigned char *) RelinquishMagickMemory(pixels);
1320         /*
1321           Write matte mask.
1322         */
1323         scanline_pad=(((next->columns+31) & ~31)-next->columns) >> 3;
1324         for (y=((ssize_t) next->rows - 1); y >= 0; y--)
1325         {
1326           p=GetVirtualPixels(next,0,y,next->columns,1,exception);
1327           if (p == (const Quantum *) NULL)
1328             break;
1329           bit=0;
1330           byte=0;
1331           for (x=0; x < (ssize_t) next->columns; x++)
1332           {
1333             byte<<=1;
1334             if ((next->alpha_trait != UndefinedPixelTrait) &&
1335                 (GetPixelAlpha(next,p) == (Quantum) TransparentAlpha))
1336               byte|=0x01;
1337             bit++;
1338             if (bit == 8)
1339               {
1340                 (void) WriteBlobByte(image,(unsigned char) byte);
1341                 bit=0;
1342                 byte=0;
1343               }
1344             p+=GetPixelChannels(next);
1345           }
1346           if (bit != 0)
1347             (void) WriteBlobByte(image,(unsigned char) (byte << (8-bit)));
1348           for (i=0; i < (ssize_t) scanline_pad; i++)
1349             (void) WriteBlobByte(image,(unsigned char) 0);
1350         }
1351       }
1352     if (GetNextImageInList(next) == (Image *) NULL)
1353       break;
1354     status=SetImageProgress(next,SaveImagesTag,scene++,
1355       GetImageListLength(next));
1356     if (status == MagickFalse)
1357       break;
1358     next=SyncNextImageInList(next);
1359   } while ((next != (Image *) NULL) && (image_info->adjoin != MagickFalse));
1360   offset=SeekBlob(image,0,SEEK_SET);
1361   (void) offset;
1362   (void) WriteBlobLSBShort(image,0);
1363   (void) WriteBlobLSBShort(image,1);
1364   (void) WriteBlobLSBShort(image,(unsigned short) (scene+1));
1365   scene=0;
1366   next=(images != (Image *) NULL) ? images : image;
1367   do
1368   {
1369     (void) WriteBlobByte(image,icon_file.directory[scene].width);
1370     (void) WriteBlobByte(image,icon_file.directory[scene].height);
1371     (void) WriteBlobByte(image,icon_file.directory[scene].colors);
1372     (void) WriteBlobByte(image,icon_file.directory[scene].reserved);
1373     (void) WriteBlobLSBShort(image,icon_file.directory[scene].planes);
1374     (void) WriteBlobLSBShort(image,icon_file.directory[scene].bits_per_pixel);
1375     (void) WriteBlobLSBLong(image,(unsigned int)
1376       icon_file.directory[scene].size);
1377     (void) WriteBlobLSBLong(image,(unsigned int)
1378       icon_file.directory[scene].offset);
1379     scene++;
1380     next=SyncNextImageInList(next);
1381   } while ((next != (Image *) NULL) && (image_info->adjoin != MagickFalse));
1382   (void) CloseBlob(image);
1383   images=DestroyImageList(images);
1384   return(MagickTrue);
1385 }