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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            BBBB   M   M  PPPP                               %
   7 %                            B   B  MM MM  P   P                              %
   8 %                            BBBB   M M M  PPPP                               %
   9 %                            B   B  M   M  P                                  %
  10 %                            BBBB   M   M  P                                  %
  11 %                                                                             %
  12 %                                                                             %
  13 %             Read/Write Microsoft Windows Bitmap Image Format                %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                   Cristy                                    %
  17 %                            Glenn Randers-Pehrson                            %
  18 %                               December 2001                                 %
  19 %                                                                             %
  20 %                                                                             %
  21 %  Copyright 1999-2018 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 %    https://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/blob.h"
  45 #include "MagickCore/blob-private.h"
  46 #include "MagickCore/cache.h"
  47 #include "MagickCore/colormap-private.h"
  48 #include "MagickCore/color-private.h"
  49 #include "MagickCore/colormap.h"
  50 #include "MagickCore/colorspace.h"
  51 #include "MagickCore/colorspace-private.h"
  52 #include "MagickCore/exception.h"
  53 #include "MagickCore/exception-private.h"
  54 #include "MagickCore/image.h"
  55 #include "MagickCore/image-private.h"
  56 #include "MagickCore/list.h"
  57 #include "MagickCore/log.h"
  58 #include "MagickCore/magick.h"
  59 #include "MagickCore/memory_.h"
  60 #include "MagickCore/monitor.h"
  61 #include "MagickCore/monitor-private.h"
  62 #include "MagickCore/option.h"
  63 #include "MagickCore/pixel-accessor.h"
  64 #include "MagickCore/profile.h"
  65 #include "MagickCore/quantum-private.h"
  66 #include "MagickCore/static.h"
  67 #include "MagickCore/string_.h"
  68 #include "MagickCore/module.h"
  69 #include "MagickCore/transform.h"
  70 \f
  71 /*
  72   Macro definitions (from Windows wingdi.h).
  73 */
  74 #undef BI_JPEG
  75 #define BI_JPEG  4
  76 #undef BI_PNG
  77 #define BI_PNG  5
  78 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__MINGW32__)
  79 #undef BI_RGB
  80 #define BI_RGB  0
  81 #undef BI_RLE8
  82 #define BI_RLE8  1
  83 #undef BI_RLE4
  84 #define BI_RLE4  2
  85 #undef BI_BITFIELDS
  86 #define BI_BITFIELDS  3
  87
  88 #undef LCS_CALIBRATED_RBG
  89 #define LCS_CALIBRATED_RBG  0
  90 #undef LCS_sRGB
  91 #define LCS_sRGB  1
  92 #undef LCS_WINDOWS_COLOR_SPACE
  93 #define LCS_WINDOWS_COLOR_SPACE  2
  94 #undef PROFILE_LINKED
  95 #define PROFILE_LINKED  3
  96 #undef PROFILE_EMBEDDED
  97 #define PROFILE_EMBEDDED  4
  98
  99 #undef LCS_GM_BUSINESS
 100 #define LCS_GM_BUSINESS  1  /* Saturation */
 101 #undef LCS_GM_GRAPHICS
 102 #define LCS_GM_GRAPHICS  2  /* Relative */
 103 #undef LCS_GM_IMAGES
 104 #define LCS_GM_IMAGES  4  /* Perceptual */
 105 #undef LCS_GM_ABS_COLORIMETRIC
 106 #define LCS_GM_ABS_COLORIMETRIC  8  /* Absolute */
 107 #endif
 108 \f
 109 /*
 110   Enumerated declaractions.
 111 */
 112 typedef enum
 113 {
 114   UndefinedSubtype,
 115   RGB555,
 116   RGB565,
 117   ARGB4444,
 118   ARGB1555
 119 } BMPSubtype;
 120
 121 /*
 122   Typedef declarations.
 123 */
 124 typedef struct _BMPInfo
 125 {
 126   unsigned int
 127     file_size,
 128     ba_offset,
 129     offset_bits,
 130     size;
 131
 132   ssize_t
 133     width,
 134     height;
 135
 136   unsigned short
 137     planes,
 138     bits_per_pixel;
 139
 140   unsigned int
 141     compression,
 142     image_size,
 143     x_pixels,
 144     y_pixels,
 145     number_colors,
 146     red_mask,
 147     green_mask,
 148     blue_mask,
 149     alpha_mask,
 150     colors_important;
 151
 152   long
 153     colorspace;
 154
 155   PrimaryInfo
 156     red_primary,
 157     green_primary,
 158     blue_primary,
 159     gamma_scale;
 160 } BMPInfo;
 161 \f
 162 /*
 163   Forward declarations.
 164 */
 165 static MagickBooleanType
 166   WriteBMPImage(const ImageInfo *,Image *,ExceptionInfo *);
 167 \f
 168 /*
 169 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 170 %                                                                             %
 171 %                                                                             %
 172 %                                                                             %
 173 %   D e c o d e I m a g e                                                     %
 174 %                                                                             %
 175 %                                                                             %
 176 %                                                                             %
 177 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 178 %
 179 %  DecodeImage unpacks the packed image pixels into runlength-encoded
 180 %  pixel packets.
 181 %
 182 %  The format of the DecodeImage method is:
 183 %
 184 %      MagickBooleanType DecodeImage(Image *image,const size_t compression,
 185 %        unsigned char *pixels,const size_t number_pixels)
 186 %
 187 %  A description of each parameter follows:
 188 %
 189 %    o image: the address of a structure of type Image.
 190 %
 191 %    o compression:  Zero means uncompressed.  A value of 1 means the
 192 %      compressed pixels are runlength encoded for a 256-color bitmap.
 193 %      A value of 2 means a 16-color bitmap.  A value of 3 means bitfields
 194 %      encoding.
 195 %
 196 %    o pixels:  The address of a byte (8 bits) array of pixel data created by
 197 %      the decoding process.
 198 %
 199 %    o number_pixels:  The number of pixels.
 200 %
 201 */
 202 static MagickBooleanType DecodeImage(Image *image,const size_t compression,
 203   unsigned char *pixels,const size_t number_pixels)
 204 {
 205   int
 206     byte,
 207     count;
 208
 209   register ssize_t
 210     i,
 211     x;
 212
 213   register unsigned char
 214     *p,
 215     *q;
 216
 217   ssize_t
 218     y;
 219
 220   assert(image != (Image *) NULL);
 221   assert(image->signature == MagickCoreSignature);
 222   if (image->debug != MagickFalse)
 223     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 224   assert(pixels != (unsigned char *) NULL);
 225   (void) memset(pixels,0,number_pixels*sizeof(*pixels));
 226   byte=0;
 227   x=0;
 228   p=pixels;
 229   q=pixels+number_pixels;
 230   for (y=0; y < (ssize_t) image->rows; )
 231   {
 232     MagickBooleanType
 233       status;
 234
 235     if ((p < pixels) || (p > q))
 236       break;
 237     count=ReadBlobByte(image);
 238     if (count == EOF)
 239       break;
 240     if (count > 0)
 241       {
 242         /*
 243           Encoded mode.
 244         */
 245         count=(int) MagickMin((ssize_t) count,(ssize_t) (q-p));
 246         byte=ReadBlobByte(image);
 247         if (byte == EOF)
 248           break;
 249         if (compression == BI_RLE8)
 250           {
 251             for (i=0; i < (ssize_t) count; i++)
 252               *p++=(unsigned char) byte;
 253           }
 254         else
 255           {
 256             for (i=0; i < (ssize_t) count; i++)
 257               *p++=(unsigned char)
 258                 ((i & 0x01) != 0 ? (byte & 0x0f) : ((byte >> 4) & 0x0f));
 259           }
 260         x+=count;
 261       }
 262     else
 263       {
 264         /*
 265           Escape mode.
 266         */
 267         count=ReadBlobByte(image);
 268         if (count == EOF)
 269           break;
 270         if (count == 0x01)
 271           return(MagickTrue);
 272         switch (count)
 273         {
 274           case 0x00:
 275           {
 276             /*
 277               End of line.
 278             */
 279             x=0;
 280             y++;
 281             p=pixels+y*image->columns;
 282             break;
 283           }
 284           case 0x02:
 285           {
 286             /*
 287               Delta mode.
 288             */
 289             x+=ReadBlobByte(image);
 290             y+=ReadBlobByte(image);
 291             p=pixels+y*image->columns+x;
 292             break;
 293           }
 294           default:
 295           {
 296             /*
 297               Absolute mode.
 298             */
 299             count=(int) MagickMin((ssize_t) count,(ssize_t) (q-p));
 300             if (compression == BI_RLE8)
 301               for (i=0; i < (ssize_t) count; i++)
 302               {
 303                 byte=ReadBlobByte(image);
 304                 if (byte == EOF)
 305                   break;
 306                 *p++=(unsigned char) byte;
 307               }
 308             else
 309               for (i=0; i < (ssize_t) count; i++)
 310               {
 311                 if ((i & 0x01) == 0)
 312                   {
 313                     byte=ReadBlobByte(image);
 314                     if (byte == EOF)
 315                       break;
 316                   }
 317                 *p++=(unsigned char)
 318                   ((i & 0x01) != 0 ? (byte & 0x0f) : ((byte >> 4) & 0x0f));
 319               }
 320             x+=count;
 321             /*
 322               Read pad byte.
 323             */
 324             if (compression == BI_RLE8)
 325               {
 326                 if ((count & 0x01) != 0)
 327                   if (ReadBlobByte(image) == EOF)
 328                     break;
 329               }
 330             else
 331               if (((count & 0x03) == 1) || ((count & 0x03) == 2))
 332                 if (ReadBlobByte(image) == EOF)
 333                   break;
 334             break;
 335           }
 336         }
 337       }
 338     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 339       image->rows);
 340     if (status == MagickFalse)
 341       break;
 342   }
 343   (void) ReadBlobByte(image);  /* end of line */
 344   (void) ReadBlobByte(image);
 345   return(y < (ssize_t) image->rows ? MagickFalse : MagickTrue);
 346 }
 347 \f
 348 /*
 349 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 350 %                                                                             %
 351 %                                                                             %
 352 %                                                                             %
 353 %   E n c o d e I m a g e                                                     %
 354 %                                                                             %
 355 %                                                                             %
 356 %                                                                             %
 357 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 358 %
 359 %  EncodeImage compresses pixels using a runlength encoded format.
 360 %
 361 %  The format of the EncodeImage method is:
 362 %
 363 %    static MagickBooleanType EncodeImage(Image *image,
 364 %      const size_t bytes_per_line,const unsigned char *pixels,
 365 %      unsigned char *compressed_pixels)
 366 %
 367 %  A description of each parameter follows:
 368 %
 369 %    o image:  The image.
 370 %
 371 %    o bytes_per_line: the number of bytes in a scanline of compressed pixels
 372 %
 373 %    o pixels:  The address of a byte (8 bits) array of pixel data created by
 374 %      the compression process.
 375 %
 376 %    o compressed_pixels:  The address of a byte (8 bits) array of compressed
 377 %      pixel data.
 378 %
 379 */
 380 static size_t EncodeImage(Image *image,const size_t bytes_per_line,
 381   const unsigned char *pixels,unsigned char *compressed_pixels)
 382 {
 383   MagickBooleanType
 384     status;
 385
 386   register const unsigned char
 387     *p;
 388
 389   register ssize_t
 390     i,
 391     x;
 392
 393   register unsigned char
 394     *q;
 395
 396   ssize_t
 397     y;
 398
 399   /*
 400     Runlength encode pixels.
 401   */
 402   assert(image != (Image *) NULL);
 403   assert(image->signature == MagickCoreSignature);
 404   if (image->debug != MagickFalse)
 405     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 406   assert(pixels != (const unsigned char *) NULL);
 407   assert(compressed_pixels != (unsigned char *) NULL);
 408   p=pixels;
 409   q=compressed_pixels;
 410   i=0;
 411   for (y=0; y < (ssize_t) image->rows; y++)
 412   {
 413     for (x=0; x < (ssize_t) bytes_per_line; x+=i)
 414     {
 415       /*
 416         Determine runlength.
 417       */
 418       for (i=1; ((x+i) < (ssize_t) bytes_per_line); i++)
 419         if ((i == 255) || (*(p+i) != *p))
 420           break;
 421       *q++=(unsigned char) i;
 422       *q++=(*p);
 423       p+=i;
 424     }
 425     /*
 426       End of line.
 427     */
 428     *q++=(unsigned char) 0x00;
 429     *q++=(unsigned char) 0x00;
 430     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 431       image->rows);
 432     if (status == MagickFalse)
 433       break;
 434   }
 435   /*
 436     End of bitmap.
 437   */
 438   *q++=(unsigned char) 0x00;
 439   *q++=(unsigned char) 0x01;
 440   return((size_t) (q-compressed_pixels));
 441 }
 442 \f
 443 /*
 444 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 445 %                                                                             %
 446 %                                                                             %
 447 %                                                                             %
 448 %   I s B M P                                                                 %
 449 %                                                                             %
 450 %                                                                             %
 451 %                                                                             %
 452 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 453 %
 454 %  IsBMP() returns MagickTrue if the image format type, identified by the
 455 %  magick string, is BMP.
 456 %
 457 %  The format of the IsBMP method is:
 458 %
 459 %      MagickBooleanType IsBMP(const unsigned char *magick,const size_t length)
 460 %
 461 %  A description of each parameter follows:
 462 %
 463 %    o magick: compare image format pattern against these bytes.
 464 %
 465 %    o length: Specifies the length of the magick string.
 466 %
 467 */
 468 static MagickBooleanType IsBMP(const unsigned char *magick,const size_t length)
 469 {
 470   if (length < 2)
 471     return(MagickFalse);
 472   if ((LocaleNCompare((char *) magick,"BA",2) == 0) ||
 473       (LocaleNCompare((char *) magick,"BM",2) == 0) ||
 474       (LocaleNCompare((char *) magick,"IC",2) == 0) ||
 475       (LocaleNCompare((char *) magick,"PI",2) == 0) ||
 476       (LocaleNCompare((char *) magick,"CI",2) == 0) ||
 477       (LocaleNCompare((char *) magick,"CP",2) == 0))
 478     return(MagickTrue);
 479   return(MagickFalse);
 480 }
 481 \f
 482 /*
 483 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 484 %                                                                             %
 485 %                                                                             %
 486 %                                                                             %
 487 %   R e a d B M P I m a g e                                                   %
 488 %                                                                             %
 489 %                                                                             %
 490 %                                                                             %
 491 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 492 %
 493 %  ReadBMPImage() reads a Microsoft Windows bitmap image file, Version
 494 %  2, 3 (for Windows or NT), or 4, and  returns it.  It allocates the memory
 495 %  necessary for the new Image structure and returns a pointer to the new
 496 %  image.
 497 %
 498 %  The format of the ReadBMPImage method is:
 499 %
 500 %      image=ReadBMPImage(image_info)
 501 %
 502 %  A description of each parameter follows:
 503 %
 504 %    o image_info: the image info.
 505 %
 506 %    o exception: return any errors or warnings in this structure.
 507 %
 508 */
 509
 510 static Image *ReadBMPImage(const ImageInfo *image_info,ExceptionInfo *exception)
 511 {
 512   BMPInfo
 513     bmp_info;
 514
 515   Image
 516     *image;
 517
 518   MagickBooleanType
 519     status;
 520
 521   MagickOffsetType
 522     offset,
 523     start_position;
 524
 525   MemoryInfo
 526     *pixel_info;
 527
 528   Quantum
 529     index;
 530
 531   register Quantum
 532     *q;
 533
 534   register ssize_t
 535     i,
 536     x;
 537
 538   register unsigned char
 539     *p;
 540
 541   size_t
 542     bit,
 543     bytes_per_line,
 544     length;
 545
 546   ssize_t
 547     count,
 548     y;
 549
 550   unsigned char
 551     magick[12],
 552     *pixels;
 553
 554   unsigned int
 555     blue,
 556     green,
 557     offset_bits,
 558     red;
 559
 560   /*
 561     Open image file.
 562   */
 563   assert(image_info != (const ImageInfo *) NULL);
 564   assert(image_info->signature == MagickCoreSignature);
 565   if (image_info->debug != MagickFalse)
 566     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 567       image_info->filename);
 568   assert(exception != (ExceptionInfo *) NULL);
 569   assert(exception->signature == MagickCoreSignature);
 570   image=AcquireImage(image_info,exception);
 571   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 572   if (status == MagickFalse)
 573     {
 574       image=DestroyImageList(image);
 575       return((Image *) NULL);
 576     }
 577   /*
 578     Determine if this a BMP file.
 579   */
 580   (void) memset(&bmp_info,0,sizeof(bmp_info));
 581   bmp_info.ba_offset=0;
 582   start_position=0;
 583   offset_bits=0;
 584   count=ReadBlob(image,2,magick);
 585   if (count != 2)
 586     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 587   do
 588   {
 589     PixelInfo
 590       quantum_bits;
 591
 592     PixelPacket
 593       shift;
 594
 595     /*
 596       Verify BMP identifier.
 597     */
 598     if (bmp_info.ba_offset == 0)
 599       start_position=TellBlob(image)-2;
 600     bmp_info.ba_offset=0;
 601     while (LocaleNCompare((char *) magick,"BA",2) == 0)
 602     {
 603       bmp_info.file_size=ReadBlobLSBLong(image);
 604       bmp_info.ba_offset=ReadBlobLSBLong(image);
 605       bmp_info.offset_bits=ReadBlobLSBLong(image);
 606       count=ReadBlob(image,2,magick);
 607       if (count != 2)
 608         break;
 609     }
 610     if (image->debug != MagickFalse)
 611       (void) LogMagickEvent(CoderEvent,GetMagickModule(),"  Magick: %c%c",
 612         magick[0],magick[1]);
 613     if ((count != 2) || ((LocaleNCompare((char *) magick,"BM",2) != 0) &&
 614         (LocaleNCompare((char *) magick,"CI",2) != 0)))
 615       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 616     bmp_info.file_size=ReadBlobLSBLong(image);
 617     (void) ReadBlobLSBLong(image);
 618     bmp_info.offset_bits=ReadBlobLSBLong(image);
 619     bmp_info.size=ReadBlobLSBLong(image);
 620     if (image->debug != MagickFalse)
 621       (void) LogMagickEvent(CoderEvent,GetMagickModule(),"  BMP size: %u",
 622         bmp_info.size);
 623     if (bmp_info.size == 12)
 624       {
 625         /*
 626           OS/2 BMP image file.
 627         */
 628         (void) CopyMagickString(image->magick,"BMP2",MagickPathExtent);
 629         bmp_info.width=(ssize_t) ((short) ReadBlobLSBShort(image));
 630         bmp_info.height=(ssize_t) ((short) ReadBlobLSBShort(image));
 631         bmp_info.planes=ReadBlobLSBShort(image);
 632         bmp_info.bits_per_pixel=ReadBlobLSBShort(image);
 633         bmp_info.x_pixels=0;
 634         bmp_info.y_pixels=0;
 635         bmp_info.number_colors=0;
 636         bmp_info.compression=BI_RGB;
 637         bmp_info.image_size=0;
 638         bmp_info.alpha_mask=0;
 639         if (image->debug != MagickFalse)
 640           {
 641             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 642               "  Format: OS/2 Bitmap");
 643             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 644               "  Geometry: %.20gx%.20g",(double) bmp_info.width,(double)
 645               bmp_info.height);
 646           }
 647       }
 648     else
 649       {
 650         /*
 651           Microsoft Windows BMP image file.
 652         */
 653         if (bmp_info.size < 40)
 654           ThrowReaderException(CorruptImageError,"NonOS2HeaderSizeError");
 655         bmp_info.width=(ssize_t) ReadBlobLSBSignedLong(image);
 656         bmp_info.height=(ssize_t) ReadBlobLSBSignedLong(image);
 657         bmp_info.planes=ReadBlobLSBShort(image);
 658         bmp_info.bits_per_pixel=ReadBlobLSBShort(image);
 659         bmp_info.compression=ReadBlobLSBLong(image);
 660         bmp_info.image_size=ReadBlobLSBLong(image);
 661         bmp_info.x_pixels=ReadBlobLSBLong(image);
 662         bmp_info.y_pixels=ReadBlobLSBLong(image);
 663         bmp_info.number_colors=ReadBlobLSBLong(image);
 664         if (bmp_info.number_colors > GetBlobSize(image))
 665           ThrowReaderException(CorruptImageError,"InsufficientImageDataInFile");
 666         bmp_info.colors_important=ReadBlobLSBLong(image);
 667         if (image->debug != MagickFalse)
 668           {
 669             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 670               "  Format: MS Windows bitmap");
 671             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 672               "  Geometry: %.20gx%.20g",(double) bmp_info.width,(double)
 673               bmp_info.height);
 674             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 675               "  Bits per pixel: %.20g",(double) bmp_info.bits_per_pixel);
 676             switch (bmp_info.compression)
 677             {
 678               case BI_RGB:
 679               {
 680                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 681                   "  Compression: BI_RGB");
 682                 break;
 683               }
 684               case BI_RLE4:
 685               {
 686                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 687                   "  Compression: BI_RLE4");
 688                 break;
 689               }
 690               case BI_RLE8:
 691               {
 692                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 693                   "  Compression: BI_RLE8");
 694                 break;
 695               }
 696               case BI_BITFIELDS:
 697               {
 698                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 699                   "  Compression: BI_BITFIELDS");
 700                 break;
 701               }
 702               case BI_PNG:
 703               {
 704                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 705                   "  Compression: BI_PNG");
 706                 break;
 707               }
 708               case BI_JPEG:
 709               {
 710                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 711                   "  Compression: BI_JPEG");
 712                 break;
 713               }
 714               default:
 715               {
 716                 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 717                   "  Compression: UNKNOWN (%u)",bmp_info.compression);
 718               }
 719             }
 720             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 721               "  Number of colors: %u",bmp_info.number_colors);
 722           }
 723         bmp_info.red_mask=ReadBlobLSBLong(image);
 724         bmp_info.green_mask=ReadBlobLSBLong(image);
 725         bmp_info.blue_mask=ReadBlobLSBLong(image);
 726         if (bmp_info.size > 40)
 727           {
 728             double
 729               gamma;
 730
 731             /*
 732               Read color management information.
 733             */
 734             bmp_info.alpha_mask=ReadBlobLSBLong(image);
 735             bmp_info.colorspace=ReadBlobLSBSignedLong(image);
 736             /*
 737               Decode 2^30 fixed point formatted CIE primaries.
 738             */
 739 #           define BMP_DENOM ((double) 0x40000000)
 740             bmp_info.red_primary.x=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 741             bmp_info.red_primary.y=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 742             bmp_info.red_primary.z=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 743             bmp_info.green_primary.x=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 744             bmp_info.green_primary.y=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 745             bmp_info.green_primary.z=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 746             bmp_info.blue_primary.x=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 747             bmp_info.blue_primary.y=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 748             bmp_info.blue_primary.z=(double) ReadBlobLSBLong(image)/BMP_DENOM;
 749
 750             gamma=bmp_info.red_primary.x+bmp_info.red_primary.y+
 751               bmp_info.red_primary.z;
 752             gamma=PerceptibleReciprocal(gamma);
 753             bmp_info.red_primary.x*=gamma;
 754             bmp_info.red_primary.y*=gamma;
 755             image->chromaticity.red_primary.x=bmp_info.red_primary.x;
 756             image->chromaticity.red_primary.y=bmp_info.red_primary.y;
 757
 758             gamma=bmp_info.green_primary.x+bmp_info.green_primary.y+
 759               bmp_info.green_primary.z;
 760             gamma=PerceptibleReciprocal(gamma);
 761             bmp_info.green_primary.x*=gamma;
 762             bmp_info.green_primary.y*=gamma;
 763             image->chromaticity.green_primary.x=bmp_info.green_primary.x;
 764             image->chromaticity.green_primary.y=bmp_info.green_primary.y;
 765
 766             gamma=bmp_info.blue_primary.x+bmp_info.blue_primary.y+
 767               bmp_info.blue_primary.z;
 768             gamma=PerceptibleReciprocal(gamma);
 769             bmp_info.blue_primary.x*=gamma;
 770             bmp_info.blue_primary.y*=gamma;
 771             image->chromaticity.blue_primary.x=bmp_info.blue_primary.x;
 772             image->chromaticity.blue_primary.y=bmp_info.blue_primary.y;
 773
 774             /*
 775               Decode 16^16 fixed point formatted gamma_scales.
 776             */
 777             bmp_info.gamma_scale.x=(double) ReadBlobLSBLong(image)/0x10000;
 778             bmp_info.gamma_scale.y=(double) ReadBlobLSBLong(image)/0x10000;
 779             bmp_info.gamma_scale.z=(double) ReadBlobLSBLong(image)/0x10000;
 780             /*
 781               Compute a single gamma from the BMP 3-channel gamma.
 782             */
 783             image->gamma=(bmp_info.gamma_scale.x+bmp_info.gamma_scale.y+
 784               bmp_info.gamma_scale.z)/3.0;
 785           }
 786         else
 787           (void) CopyMagickString(image->magick,"BMP3",MagickPathExtent);
 788
 789         if (bmp_info.size > 108)
 790           {
 791             size_t
 792               intent;
 793
 794             /*
 795               Read BMP Version 5 color management information.
 796             */
 797             intent=ReadBlobLSBLong(image);
 798             switch ((int) intent)
 799             {
 800               case LCS_GM_BUSINESS:
 801               {
 802                 image->rendering_intent=SaturationIntent;
 803                 break;
 804               }
 805               case LCS_GM_GRAPHICS:
 806               {
 807                 image->rendering_intent=RelativeIntent;
 808                 break;
 809               }
 810               case LCS_GM_IMAGES:
 811               {
 812                 image->rendering_intent=PerceptualIntent;
 813                 break;
 814               }
 815               case LCS_GM_ABS_COLORIMETRIC:
 816               {
 817                 image->rendering_intent=AbsoluteIntent;
 818                 break;
 819               }
 820             }
 821             (void) ReadBlobLSBLong(image);  /* Profile data */
 822             (void) ReadBlobLSBLong(image);  /* Profile size */
 823             (void) ReadBlobLSBLong(image);  /* Reserved byte */
 824           }
 825       }
 826     if ((MagickSizeType) bmp_info.file_size > GetBlobSize(image))
 827       (void) ThrowMagickException(exception,GetMagickModule(),CorruptImageError,
 828         "LengthAndFilesizeDoNotMatch","`%s'",image->filename);
 829     else
 830       if ((MagickSizeType) bmp_info.file_size < GetBlobSize(image))
 831         (void) ThrowMagickException(exception,GetMagickModule(),
 832           CorruptImageWarning,"LengthAndFilesizeDoNotMatch","`%s'",
 833           image->filename);
 834     if (bmp_info.width <= 0)
 835       ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");
 836     if (bmp_info.height == 0)
 837       ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");
 838     if (bmp_info.planes != 1)
 839       ThrowReaderException(CorruptImageError,"StaticPlanesValueNotEqualToOne");
 840     if ((bmp_info.bits_per_pixel != 1) && (bmp_info.bits_per_pixel != 4) &&
 841         (bmp_info.bits_per_pixel != 8) && (bmp_info.bits_per_pixel != 16) &&
 842         (bmp_info.bits_per_pixel != 24) && (bmp_info.bits_per_pixel != 32))
 843       ThrowReaderException(CorruptImageError,"UnrecognizedBitsPerPixel");
 844     if (bmp_info.bits_per_pixel < 16 &&
 845         bmp_info.number_colors > (1U << bmp_info.bits_per_pixel))
 846       ThrowReaderException(CorruptImageError,"UnrecognizedNumberOfColors");
 847     if ((bmp_info.compression == 1) && (bmp_info.bits_per_pixel != 8))
 848       ThrowReaderException(CorruptImageError,"UnrecognizedBitsPerPixel");
 849     if ((bmp_info.compression == 2) && (bmp_info.bits_per_pixel != 4))
 850       ThrowReaderException(CorruptImageError,"UnrecognizedBitsPerPixel");
 851     if ((bmp_info.compression == 3) && (bmp_info.bits_per_pixel < 16))
 852       ThrowReaderException(CorruptImageError,"UnrecognizedBitsPerPixel");
 853     switch (bmp_info.compression)
 854     {
 855       case BI_RGB:
 856         image->compression=NoCompression;
 857         break;
 858       case BI_RLE8:
 859       case BI_RLE4:
 860         image->compression=RLECompression;
 861         break;
 862       case BI_BITFIELDS:
 863         break;
 864       case BI_JPEG:
 865         ThrowReaderException(CoderError,"JPEGCompressNotSupported");
 866       case BI_PNG:
 867         ThrowReaderException(CoderError,"PNGCompressNotSupported");
 868       default:
 869         ThrowReaderException(CorruptImageError,"UnrecognizedImageCompression");
 870     }
 871     image->columns=(size_t) MagickAbsoluteValue(bmp_info.width);
 872     image->rows=(size_t) MagickAbsoluteValue(bmp_info.height);
 873     image->depth=bmp_info.bits_per_pixel <= 8 ? bmp_info.bits_per_pixel : 8;
 874     image->alpha_trait=((bmp_info.alpha_mask != 0) &&
 875       (bmp_info.compression == BI_BITFIELDS)) ? BlendPixelTrait :
 876       UndefinedPixelTrait;
 877     if (bmp_info.bits_per_pixel < 16)
 878       {
 879         size_t
 880           one;
 881
 882         image->storage_class=PseudoClass;
 883         image->colors=bmp_info.number_colors;
 884         one=1;
 885         if (image->colors == 0)
 886           image->colors=one << bmp_info.bits_per_pixel;
 887       }
 888     image->resolution.x=(double) bmp_info.x_pixels/100.0;
 889     image->resolution.y=(double) bmp_info.y_pixels/100.0;
 890     image->units=PixelsPerCentimeterResolution;
 891     if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
 892       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 893         break;
 894     status=SetImageExtent(image,image->columns,image->rows,exception);
 895     if (status == MagickFalse)
 896       return(DestroyImageList(image));
 897     if (image->storage_class == PseudoClass)
 898       {
 899         unsigned char
 900           *bmp_colormap;
 901
 902         size_t
 903           packet_size;
 904
 905         /*
 906           Read BMP raster colormap.
 907         */
 908         if (image->debug != MagickFalse)
 909           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 910             "  Reading colormap of %.20g colors",(double) image->colors);
 911         if (AcquireImageColormap(image,image->colors,exception) == MagickFalse)
 912           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 913         bmp_colormap=(unsigned char *) AcquireQuantumMemory((size_t)
 914           image->colors,4*sizeof(*bmp_colormap));
 915         if (bmp_colormap == (unsigned char *) NULL)
 916           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 917         if ((bmp_info.size == 12) || (bmp_info.size == 64))
 918           packet_size=3;
 919         else
 920           packet_size=4;
 921         offset=SeekBlob(image,start_position+14+bmp_info.size,SEEK_SET);
 922         if (offset < 0)
 923           {
 924             bmp_colormap=(unsigned char *) RelinquishMagickMemory(bmp_colormap);
 925             ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 926           }
 927         count=ReadBlob(image,packet_size*image->colors,bmp_colormap);
 928         if (count != (ssize_t) (packet_size*image->colors))
 929           {
 930             bmp_colormap=(unsigned char *) RelinquishMagickMemory(bmp_colormap);
 931             ThrowReaderException(CorruptImageError,
 932               "InsufficientImageDataInFile");
 933           }
 934         p=bmp_colormap;
 935         for (i=0; i < (ssize_t) image->colors; i++)
 936         {
 937           image->colormap[i].blue=(MagickRealType) ScaleCharToQuantum(*p++);
 938           image->colormap[i].green=(MagickRealType) ScaleCharToQuantum(*p++);
 939           image->colormap[i].red=(MagickRealType) ScaleCharToQuantum(*p++);
 940           if (packet_size == 4)
 941             p++;
 942         }
 943         bmp_colormap=(unsigned char *) RelinquishMagickMemory(bmp_colormap);
 944       }
 945     /*
 946       Read image data.
 947     */
 948     if (bmp_info.offset_bits == offset_bits)
 949       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 950     offset_bits=bmp_info.offset_bits;
 951     offset=SeekBlob(image,start_position+bmp_info.offset_bits,SEEK_SET);
 952     if (offset < 0)
 953       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 954     if (bmp_info.compression == BI_RLE4)
 955       bmp_info.bits_per_pixel<<=1;
 956     bytes_per_line=4*((image->columns*bmp_info.bits_per_pixel+31)/32);
 957     length=(size_t) bytes_per_line*image->rows;
 958     if (((MagickSizeType) length/8) > GetBlobSize(image))
 959       ThrowReaderException(CorruptImageError,"InsufficientImageDataInFile");
 960     if ((bmp_info.compression == BI_RGB) ||
 961         (bmp_info.compression == BI_BITFIELDS))
 962       {
 963         pixel_info=AcquireVirtualMemory(image->rows,
 964           MagickMax(bytes_per_line,image->columns+256UL)*sizeof(*pixels));
 965         if (pixel_info == (MemoryInfo *) NULL)
 966           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 967         pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
 968         if (image->debug != MagickFalse)
 969           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 970             "  Reading pixels (%.20g bytes)",(double) length);
 971         count=ReadBlob(image,length,pixels);
 972         if (count != (ssize_t) length)
 973           {
 974             pixel_info=RelinquishVirtualMemory(pixel_info);
 975             ThrowReaderException(CorruptImageError,
 976               "InsufficientImageDataInFile");
 977           }
 978       }
 979     else
 980       {
 981         /*
 982           Convert run-length encoded raster pixels.
 983         */
 984         pixel_info=AcquireVirtualMemory(image->rows,
 985           MagickMax(bytes_per_line,image->columns+256UL)*sizeof(*pixels));
 986         if (pixel_info == (MemoryInfo *) NULL)
 987           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 988         pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
 989         status=DecodeImage(image,bmp_info.compression,pixels,
 990           image->columns*image->rows);
 991         if (status == MagickFalse)
 992           {
 993             pixel_info=RelinquishVirtualMemory(pixel_info);
 994             ThrowReaderException(CorruptImageError,
 995               "UnableToRunlengthDecodeImage");
 996           }
 997       }
 998     /*
 999       Convert BMP raster image to pixel packets.
1000     */
1001     if (bmp_info.compression == BI_RGB)
1002       {
1003         /*
1004           We should ignore the alpha value in BMP3 files but there have been
1005           reports about 32 bit files with alpha. We do a quick check to see if
1006           the alpha channel contains a value that is not zero (default value).
1007           If we find a non zero value we asume the program that wrote the file
1008           wants to use the alpha channel.
1009         */
1010         if ((image->alpha_trait == UndefinedPixelTrait) && (bmp_info.size == 40) &&
1011             (bmp_info.bits_per_pixel == 32))
1012           {
1013             bytes_per_line=4*(image->columns);
1014             for (y=(ssize_t) image->rows-1; y >= 0; y--)
1015             {
1016               p=pixels+(image->rows-y-1)*bytes_per_line;
1017               for (x=0; x < (ssize_t) image->columns; x++)
1018               {
1019                 if (*(p+3) != 0)
1020                   {
1021                     image->alpha_trait=BlendPixelTrait;
1022                     y=-1;
1023                     break;
1024                   }
1025                 p+=4;
1026               }
1027             }
1028           }
1029         bmp_info.alpha_mask=image->alpha_trait != UndefinedPixelTrait ?
1030           0xff000000U : 0U;
1031         bmp_info.red_mask=0x00ff0000U;
1032         bmp_info.green_mask=0x0000ff00U;
1033         bmp_info.blue_mask=0x000000ffU;
1034         if (bmp_info.bits_per_pixel == 16)
1035           {
1036             /*
1037               RGB555.
1038             */
1039             bmp_info.red_mask=0x00007c00U;
1040             bmp_info.green_mask=0x000003e0U;
1041             bmp_info.blue_mask=0x0000001fU;
1042           }
1043       }
1044     (void) memset(&shift,0,sizeof(shift));
1045     (void) memset(&quantum_bits,0,sizeof(quantum_bits));
1046     if ((bmp_info.bits_per_pixel == 16) || (bmp_info.bits_per_pixel == 32))
1047       {
1048         register unsigned int
1049           sample;
1050
1051         /*
1052           Get shift and quantum bits info from bitfield masks.
1053         */
1054         if (bmp_info.red_mask != 0)
1055           while (((bmp_info.red_mask << shift.red) & 0x80000000UL) == 0)
1056           {
1057             shift.red++;
1058             if (shift.red >= 32U)
1059               break;
1060           }
1061         if (bmp_info.green_mask != 0)
1062           while (((bmp_info.green_mask << shift.green) & 0x80000000UL) == 0)
1063           {
1064             shift.green++;
1065             if (shift.green >= 32U)
1066               break;
1067           }
1068         if (bmp_info.blue_mask != 0)
1069           while (((bmp_info.blue_mask << shift.blue) & 0x80000000UL) == 0)
1070           {
1071             shift.blue++;
1072             if (shift.blue >= 32U)
1073               break;
1074           }
1075         if (bmp_info.alpha_mask != 0)
1076           while (((bmp_info.alpha_mask << shift.alpha) & 0x80000000UL) == 0)
1077           {
1078             shift.alpha++;
1079             if (shift.alpha >= 32U)
1080               break;
1081           }
1082         sample=shift.red;
1083         while (((bmp_info.red_mask << sample) & 0x80000000UL) != 0)
1084         {
1085           sample++;
1086           if (sample >= 32U)
1087             break;
1088         }
1089         quantum_bits.red=(MagickRealType) (sample-shift.red);
1090         sample=shift.green;
1091         while (((bmp_info.green_mask << sample) & 0x80000000UL) != 0)
1092         {
1093           sample++;
1094           if (sample >= 32U)
1095             break;
1096         }
1097         quantum_bits.green=(MagickRealType) (sample-shift.green);
1098         sample=shift.blue;
1099         while (((bmp_info.blue_mask << sample) & 0x80000000UL) != 0)
1100         {
1101           sample++;
1102           if (sample >= 32U)
1103             break;
1104         }
1105         quantum_bits.blue=(MagickRealType) (sample-shift.blue);
1106         sample=shift.alpha;
1107         while (((bmp_info.alpha_mask << sample) & 0x80000000UL) != 0)
1108         {
1109           sample++;
1110           if (sample >= 32U)
1111             break;
1112         }
1113         quantum_bits.alpha=(MagickRealType) (sample-shift.alpha);
1114       }
1115     switch (bmp_info.bits_per_pixel)
1116     {
1117       case 1:
1118       {
1119         /*
1120           Convert bitmap scanline.
1121         */
1122         for (y=(ssize_t) image->rows-1; y >= 0; y--)
1123         {
1124           p=pixels+(image->rows-y-1)*bytes_per_line;
1125           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
1126           if (q == (Quantum *) NULL)
1127             break;
1128           for (x=0; x < ((ssize_t) image->columns-7); x+=8)
1129           {
1130             for (bit=0; bit < 8; bit++)
1131             {
1132               index=(Quantum) (((*p) & (0x80 >> bit)) != 0 ? 0x01 : 0x00);
1133               SetPixelIndex(image,index,q);
1134               q+=GetPixelChannels(image);
1135             }
1136             p++;
1137           }
1138           if ((image->columns % 8) != 0)
1139             {
1140               for (bit=0; bit < (image->columns % 8); bit++)
1141               {
1142                 index=(Quantum) (((*p) & (0x80 >> bit)) != 0 ? 0x01 : 0x00);
1143                 SetPixelIndex(image,index,q);
1144                 q+=GetPixelChannels(image);
1145               }
1146               p++;
1147             }
1148           if (SyncAuthenticPixels(image,exception) == MagickFalse)
1149             break;
1150           if (image->previous == (Image *) NULL)
1151             {
1152               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
1153                 (image->rows-y),image->rows);
1154               if (status == MagickFalse)
1155                 break;
1156             }
1157         }
1158         (void) SyncImage(image,exception);
1159         break;
1160       }
1161       case 4:
1162       {
1163         /*
1164           Convert PseudoColor scanline.
1165         */
1166         for (y=(ssize_t) image->rows-1; y >= 0; y--)
1167         {
1168           p=pixels+(image->rows-y-1)*bytes_per_line;
1169           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
1170           if (q == (Quantum *) NULL)
1171             break;
1172           for (x=0; x < ((ssize_t) image->columns-1); x+=2)
1173           {
1174             ValidateColormapValue(image,(ssize_t) ((*p >> 4) & 0x0f),&index,
1175               exception);
1176             SetPixelIndex(image,index,q);
1177             q+=GetPixelChannels(image);
1178             ValidateColormapValue(image,(ssize_t) (*p & 0x0f),&index,exception);
1179             SetPixelIndex(image,index,q);
1180             q+=GetPixelChannels(image);
1181             p++;
1182           }
1183           if ((image->columns % 2) != 0)
1184             {
1185               ValidateColormapValue(image,(ssize_t) ((*p >> 4) & 0xf),&index,
1186                 exception);
1187               SetPixelIndex(image,index,q);
1188               q+=GetPixelChannels(image);
1189               p++;
1190               x++;
1191             }
1192           if (x < (ssize_t) image->columns)
1193             break;
1194           if (SyncAuthenticPixels(image,exception) == MagickFalse)
1195             break;
1196           if (image->previous == (Image *) NULL)
1197             {
1198               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
1199                 (image->rows-y),image->rows);
1200               if (status == MagickFalse)
1201                 break;
1202             }
1203         }
1204         (void) SyncImage(image,exception);
1205         break;
1206       }
1207       case 8:
1208       {
1209         /*
1210           Convert PseudoColor scanline.
1211         */
1212         if ((bmp_info.compression == BI_RLE8) ||
1213             (bmp_info.compression == BI_RLE4))
1214           bytes_per_line=image->columns;
1215         for (y=(ssize_t) image->rows-1; y >= 0; y--)
1216         {
1217           p=pixels+(image->rows-y-1)*bytes_per_line;
1218           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
1219           if (q == (Quantum *) NULL)
1220             break;
1221           for (x=(ssize_t) image->columns; x != 0; --x)
1222           {
1223             ValidateColormapValue(image,(ssize_t) *p++,&index,exception);
1224             SetPixelIndex(image,index,q);
1225             q+=GetPixelChannels(image);
1226           }
1227           if (SyncAuthenticPixels(image,exception) == MagickFalse)
1228             break;
1229           offset=(MagickOffsetType) (image->rows-y-1);
1230           if (image->previous == (Image *) NULL)
1231             {
1232               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
1233                 (image->rows-y),image->rows);
1234               if (status == MagickFalse)
1235                 break;
1236             }
1237         }
1238         (void) SyncImage(image,exception);
1239         break;
1240       }
1241       case 16:
1242       {
1243         unsigned int
1244           alpha,
1245           pixel;
1246
1247         /*
1248           Convert bitfield encoded 16-bit PseudoColor scanline.
1249         */
1250         if ((bmp_info.compression != BI_RGB) &&
1251             (bmp_info.compression != BI_BITFIELDS))
1252           {
1253             pixel_info=RelinquishVirtualMemory(pixel_info);
1254             ThrowReaderException(CorruptImageError,
1255               "UnrecognizedImageCompression");
1256           }
1257         bytes_per_line=2*(image->columns+image->columns % 2);
1258         image->storage_class=DirectClass;
1259         for (y=(ssize_t) image->rows-1; y >= 0; y--)
1260         {
1261           p=pixels+(image->rows-y-1)*bytes_per_line;
1262           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
1263           if (q == (Quantum *) NULL)
1264             break;
1265           for (x=0; x < (ssize_t) image->columns; x++)
1266           {
1267             pixel=(unsigned int) (*p++);
1268             pixel|=(*p++) << 8;
1269             red=((pixel & bmp_info.red_mask) << shift.red) >> 16;
1270             if (quantum_bits.red == 5)
1271               red|=((red & 0xe000) >> 5);
1272             if (quantum_bits.red <= 8)
1273               red|=((red & 0xff00) >> 8);
1274             green=((pixel & bmp_info.green_mask) << shift.green) >> 16;
1275             if (quantum_bits.green == 5)
1276               green|=((green & 0xe000) >> 5);
1277             if (quantum_bits.green == 6)
1278               green|=((green & 0xc000) >> 6);
1279             if (quantum_bits.green <= 8)
1280               green|=((green & 0xff00) >> 8);
1281             blue=((pixel & bmp_info.blue_mask) << shift.blue) >> 16;
1282             if (quantum_bits.blue == 5)
1283               blue|=((blue & 0xe000) >> 5);
1284             if (quantum_bits.blue <= 8)
1285               blue|=((blue & 0xff00) >> 8);
1286             SetPixelRed(image,ScaleShortToQuantum((unsigned short) red),q);
1287             SetPixelGreen(image,ScaleShortToQuantum((unsigned short) green),q);
1288             SetPixelBlue(image,ScaleShortToQuantum((unsigned short) blue),q);
1289             SetPixelAlpha(image,OpaqueAlpha,q);
1290             if (image->alpha_trait != UndefinedPixelTrait)
1291               {
1292                 alpha=((pixel & bmp_info.alpha_mask) << shift.alpha) >> 16;
1293                 if (quantum_bits.alpha <= 8)
1294                   alpha|=((alpha & 0xff00) >> 8);
1295                 SetPixelAlpha(image,ScaleShortToQuantum(
1296                   (unsigned short) alpha),q);
1297               }
1298             q+=GetPixelChannels(image);
1299           }
1300           if (SyncAuthenticPixels(image,exception) == MagickFalse)
1301             break;
1302           offset=(MagickOffsetType) (image->rows-y-1);
1303           if (image->previous == (Image *) NULL)
1304             {
1305               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
1306                 (image->rows-y),image->rows);
1307               if (status == MagickFalse)
1308                 break;
1309             }
1310         }
1311         break;
1312       }
1313       case 24:
1314       {
1315         /*
1316           Convert DirectColor scanline.
1317         */
1318         bytes_per_line=4*((image->columns*24+31)/32);
1319         for (y=(ssize_t) image->rows-1; y >= 0; y--)
1320         {
1321           p=pixels+(image->rows-y-1)*bytes_per_line;
1322           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
1323           if (q == (Quantum *) NULL)
1324             break;
1325           for (x=0; x < (ssize_t) image->columns; x++)
1326           {
1327             SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
1328             SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
1329             SetPixelRed(image,ScaleCharToQuantum(*p++),q);
1330             SetPixelAlpha(image,OpaqueAlpha,q);
1331             q+=GetPixelChannels(image);
1332           }
1333           if (SyncAuthenticPixels(image,exception) == MagickFalse)
1334             break;
1335           offset=(MagickOffsetType) (image->rows-y-1);
1336           if (image->previous == (Image *) NULL)
1337             {
1338               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
1339                 (image->rows-y),image->rows);
1340               if (status == MagickFalse)
1341                 break;
1342             }
1343         }
1344         break;
1345       }
1346       case 32:
1347       {
1348         /*
1349           Convert bitfield encoded DirectColor scanline.
1350         */
1351         if ((bmp_info.compression != BI_RGB) &&
1352             (bmp_info.compression != BI_BITFIELDS))
1353           {
1354             pixel_info=RelinquishVirtualMemory(pixel_info);
1355             ThrowReaderException(CorruptImageError,
1356               "UnrecognizedImageCompression");
1357           }
1358         bytes_per_line=4*(image->columns);
1359         for (y=(ssize_t) image->rows-1; y >= 0; y--)
1360         {
1361           unsigned int
1362             alpha,
1363             pixel;
1364
1365           p=pixels+(image->rows-y-1)*bytes_per_line;
1366           q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
1367           if (q == (Quantum *) NULL)
1368             break;
1369           for (x=0; x < (ssize_t) image->columns; x++)
1370           {
1371             pixel=(unsigned int) (*p++);
1372             pixel|=((unsigned int) *p++ << 8);
1373             pixel|=((unsigned int) *p++ << 16);
1374             pixel|=((unsigned int) *p++ << 24);
1375             red=((pixel & bmp_info.red_mask) << shift.red) >> 16;
1376             if (quantum_bits.red == 8)
1377               red|=(red >> 8);
1378             green=((pixel & bmp_info.green_mask) << shift.green) >> 16;
1379             if (quantum_bits.green == 8)
1380               green|=(green >> 8);
1381             blue=((pixel & bmp_info.blue_mask) << shift.blue) >> 16;
1382             if (quantum_bits.blue == 8)
1383               blue|=(blue >> 8);
1384             SetPixelRed(image,ScaleShortToQuantum((unsigned short) red),q);
1385             SetPixelGreen(image,ScaleShortToQuantum((unsigned short) green),q);
1386             SetPixelBlue(image,ScaleShortToQuantum((unsigned short) blue),q);
1387             SetPixelAlpha(image,OpaqueAlpha,q);
1388             if (image->alpha_trait != UndefinedPixelTrait)
1389               {
1390                 alpha=((pixel & bmp_info.alpha_mask) << shift.alpha) >> 16;
1391                 if (quantum_bits.alpha == 8)
1392                   alpha|=(alpha >> 8);
1393                 SetPixelAlpha(image,ScaleShortToQuantum(
1394                   (unsigned short) alpha),q);
1395               }
1396             q+=GetPixelChannels(image);
1397           }
1398           if (SyncAuthenticPixels(image,exception) == MagickFalse)
1399             break;
1400           offset=(MagickOffsetType) (image->rows-y-1);
1401           if (image->previous == (Image *) NULL)
1402             {
1403               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType)
1404                 (image->rows-y),image->rows);
1405               if (status == MagickFalse)
1406                 break;
1407             }
1408         }
1409         break;
1410       }
1411       default:
1412       {
1413         pixel_info=RelinquishVirtualMemory(pixel_info);
1414         ThrowReaderException(CorruptImageError,"ImproperImageHeader");
1415       }
1416     }
1417     pixel_info=RelinquishVirtualMemory(pixel_info);
1418     if (y > 0)
1419       break;
1420     if (EOFBlob(image) != MagickFalse)
1421       {
1422         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
1423           image->filename);
1424         break;
1425       }
1426     if (bmp_info.height < 0)
1427       {
1428         Image
1429           *flipped_image;
1430
1431         /*
1432           Correct image orientation.
1433         */
1434         flipped_image=FlipImage(image,exception);
1435         if (flipped_image != (Image *) NULL)
1436           {
1437             DuplicateBlob(flipped_image,image);
1438             ReplaceImageInList(&image, flipped_image);
1439             image=flipped_image;
1440           }
1441       }
1442     /*
1443       Proceed to next image.
1444     */
1445     if (image_info->number_scenes != 0)
1446       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
1447         break;
1448     *magick='\0';
1449     if (bmp_info.ba_offset != 0)
1450       {
1451         offset=SeekBlob(image,(MagickOffsetType) bmp_info.ba_offset,SEEK_SET);
1452         if (offset < 0)
1453           ThrowReaderException(CorruptImageError,"ImproperImageHeader");
1454       }
1455     count=ReadBlob(image,2,magick);
1456     if ((count == 2) && (IsBMP(magick,2) != MagickFalse))
1457       {
1458         /*
1459           Acquire next image structure.
1460         */
1461         AcquireNextImage(image_info,image,exception);
1462         if (GetNextImageInList(image) == (Image *) NULL)
1463           {
1464             status=MagickFalse;
1465             return((Image *) NULL);
1466           }
1467         image=SyncNextImageInList(image);
1468         status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
1469           GetBlobSize(image));
1470         if (status == MagickFalse)
1471           break;
1472       }
1473   } while (IsBMP(magick,2) != MagickFalse);
1474   (void) CloseBlob(image);
1475   if (status == MagickFalse)
1476     return(DestroyImageList(image));
1477   return(GetFirstImageInList(image));
1478 }
1479 \f
1480 /*
1481 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1482 %                                                                             %
1483 %                                                                             %
1484 %                                                                             %
1485 %   R e g i s t e r B M P I m a g e                                           %
1486 %                                                                             %
1487 %                                                                             %
1488 %                                                                             %
1489 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1490 %
1491 %  RegisterBMPImage() adds attributes for the BMP image format to
1492 %  the list of supported formats.  The attributes include the image format
1493 %  tag, a method to read and/or write the format, whether the format
1494 %  supports the saving of more than one frame to the same file or blob,
1495 %  whether the format supports native in-memory I/O, and a brief
1496 %  description of the format.
1497 %
1498 %  The format of the RegisterBMPImage method is:
1499 %
1500 %      size_t RegisterBMPImage(void)
1501 %
1502 */
1503 ModuleExport size_t RegisterBMPImage(void)
1504 {
1505   MagickInfo
1506     *entry;
1507
1508   entry=AcquireMagickInfo("BMP","BMP","Microsoft Windows bitmap image");
1509   entry->decoder=(DecodeImageHandler *) ReadBMPImage;
1510   entry->encoder=(EncodeImageHandler *) WriteBMPImage;
1511   entry->magick=(IsImageFormatHandler *) IsBMP;
1512   entry->flags^=CoderAdjoinFlag;
1513   entry->flags|=CoderDecoderSeekableStreamFlag;
1514   (void) RegisterMagickInfo(entry);
1515   entry=AcquireMagickInfo("BMP","BMP2","Microsoft Windows bitmap image (V2)");
1516   entry->decoder=(DecodeImageHandler *) ReadBMPImage;
1517   entry->encoder=(EncodeImageHandler *) WriteBMPImage;
1518   entry->magick=(IsImageFormatHandler *) IsBMP;
1519   entry->flags^=CoderAdjoinFlag;
1520   entry->flags|=CoderDecoderSeekableStreamFlag;
1521   (void) RegisterMagickInfo(entry);
1522   entry=AcquireMagickInfo("BMP","BMP3","Microsoft Windows bitmap image (V3)");
1523   entry->decoder=(DecodeImageHandler *) ReadBMPImage;
1524   entry->encoder=(EncodeImageHandler *) WriteBMPImage;
1525   entry->magick=(IsImageFormatHandler *) IsBMP;
1526   entry->flags^=CoderAdjoinFlag;
1527   entry->flags|=CoderDecoderSeekableStreamFlag;
1528   (void) RegisterMagickInfo(entry);
1529   return(MagickImageCoderSignature);
1530 }
1531 \f
1532 /*
1533 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1534 %                                                                             %
1535 %                                                                             %
1536 %                                                                             %
1537 %   U n r e g i s t e r B M P I m a g e                                       %
1538 %                                                                             %
1539 %                                                                             %
1540 %                                                                             %
1541 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1542 %
1543 %  UnregisterBMPImage() removes format registrations made by the
1544 %  BMP module from the list of supported formats.
1545 %
1546 %  The format of the UnregisterBMPImage method is:
1547 %
1548 %      UnregisterBMPImage(void)
1549 %
1550 */
1551 ModuleExport void UnregisterBMPImage(void)
1552 {
1553   (void) UnregisterMagickInfo("BMP");
1554   (void) UnregisterMagickInfo("BMP2");
1555   (void) UnregisterMagickInfo("BMP3");
1556 }
1557 \f
1558 /*
1559 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1560 %                                                                             %
1561 %                                                                             %
1562 %                                                                             %
1563 %   W r i t e B M P I m a g e                                                 %
1564 %                                                                             %
1565 %                                                                             %
1566 %                                                                             %
1567 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1568 %
1569 %  WriteBMPImage() writes an image in Microsoft Windows bitmap encoded
1570 %  image format, version 3 for Windows or (if the image has a matte channel)
1571 %  version 4.
1572 %
1573 %  The format of the WriteBMPImage method is:
1574 %
1575 %      MagickBooleanType WriteBMPImage(const ImageInfo *image_info,
1576 %        Image *image,ExceptionInfo *exception)
1577 %
1578 %  A description of each parameter follows.
1579 %
1580 %    o image_info: the image info.
1581 %
1582 %    o image:  The image.
1583 %
1584 %    o exception: return any errors or warnings in this structure.
1585 %
1586 */
1587 static MagickBooleanType WriteBMPImage(const ImageInfo *image_info,Image *image,
1588   ExceptionInfo *exception)
1589 {
1590   BMPInfo
1591     bmp_info;
1592
1593   BMPSubtype
1594     bmp_subtype;
1595
1596   const char
1597     *option;
1598
1599   const StringInfo
1600     *profile;
1601
1602   MagickBooleanType
1603     have_color_info,
1604     status;
1605
1606   MagickOffsetType
1607     scene;
1608
1609   MemoryInfo
1610     *pixel_info;
1611
1612   register const Quantum
1613     *p;
1614
1615   register ssize_t
1616     i,
1617     x;
1618
1619   register unsigned char
1620     *q;
1621
1622   size_t
1623     bytes_per_line,
1624     imageListLength,
1625     type;
1626
1627   ssize_t
1628     y;
1629
1630   unsigned char
1631     *bmp_data,
1632     *pixels;
1633
1634   /*
1635     Open output image file.
1636   */
1637   assert(image_info != (const ImageInfo *) NULL);
1638   assert(image_info->signature == MagickCoreSignature);
1639   assert(image != (Image *) NULL);
1640   assert(image->signature == MagickCoreSignature);
1641   if (image->debug != MagickFalse)
1642     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1643   assert(exception != (ExceptionInfo *) NULL);
1644   assert(exception->signature == MagickCoreSignature);
1645   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1646   if (status == MagickFalse)
1647     return(status);
1648   type=4;
1649   if (LocaleCompare(image_info->magick,"BMP2") == 0)
1650     type=2;
1651   else
1652     if (LocaleCompare(image_info->magick,"BMP3") == 0)
1653       type=3;
1654   option=GetImageOption(image_info,"bmp:format");
1655   if (option != (char *) NULL)
1656     {
1657       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
1658           "  Format=%s",option);
1659       if (LocaleCompare(option,"bmp2") == 0)
1660         type=2;
1661       if (LocaleCompare(option,"bmp3") == 0)
1662         type=3;
1663       if (LocaleCompare(option,"bmp4") == 0)
1664         type=4;
1665     }
1666   scene=0;
1667   imageListLength=GetImageListLength(image);
1668   do
1669   {
1670     /*
1671       Initialize BMP raster file header.
1672     */
1673     if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
1674       (void) TransformImageColorspace(image,sRGBColorspace,exception);
1675     (void) memset(&bmp_info,0,sizeof(bmp_info));
1676     bmp_info.file_size=14+12;
1677     if (type > 2)
1678       bmp_info.file_size+=28;
1679     bmp_info.offset_bits=bmp_info.file_size;
1680     bmp_info.compression=BI_RGB;
1681     bmp_info.red_mask=0x00ff0000U;
1682     bmp_info.green_mask=0x0000ff00U;
1683     bmp_info.blue_mask=0x000000ffU;
1684     bmp_info.alpha_mask=0xff000000U;
1685     bmp_subtype=UndefinedSubtype;
1686     if ((image->storage_class == PseudoClass) && (image->colors > 256))
1687       (void) SetImageStorageClass(image,DirectClass,exception);
1688     if (image->storage_class != DirectClass)
1689       {
1690         /*
1691           Colormapped BMP raster.
1692         */
1693         bmp_info.bits_per_pixel=8;
1694         if (image->colors <= 2)
1695           bmp_info.bits_per_pixel=1;
1696         else
1697           if (image->colors <= 16)
1698             bmp_info.bits_per_pixel=4;
1699           else
1700             if (image->colors <= 256)
1701               bmp_info.bits_per_pixel=8;
1702         if (image_info->compression == RLECompression)
1703           bmp_info.bits_per_pixel=8;
1704         bmp_info.number_colors=1U << bmp_info.bits_per_pixel;
1705         if (image->alpha_trait != UndefinedPixelTrait)
1706           (void) SetImageStorageClass(image,DirectClass,exception);
1707         else
1708           if ((size_t) bmp_info.number_colors < image->colors)
1709             (void) SetImageStorageClass(image,DirectClass,exception);
1710           else
1711             {
1712               bmp_info.file_size+=3*(1UL << bmp_info.bits_per_pixel);
1713               bmp_info.offset_bits+=3*(1UL << bmp_info.bits_per_pixel);
1714               if (type > 2)
1715                 {
1716                   bmp_info.file_size+=(1UL << bmp_info.bits_per_pixel);
1717                   bmp_info.offset_bits+=(1UL << bmp_info.bits_per_pixel);
1718                 }
1719             }
1720       }
1721     if (image->storage_class == DirectClass)
1722       {
1723         /*
1724           Full color BMP raster.
1725         */
1726         bmp_info.number_colors=0;
1727         option=GetImageOption(image_info,"bmp:subtype");
1728         if (option != (const char *) NULL)
1729         {
1730           if (image->alpha_trait != UndefinedPixelTrait)
1731             {
1732               if (LocaleNCompare(option,"ARGB4444",8) == 0)
1733                 {
1734                   bmp_subtype=ARGB4444;
1735                   bmp_info.red_mask=0x00000f00U;
1736                   bmp_info.green_mask=0x000000f0U;
1737                   bmp_info.blue_mask=0x0000000fU;
1738                   bmp_info.alpha_mask=0x0000f000U;
1739                 }
1740               else if (LocaleNCompare(option,"ARGB1555",8) == 0)
1741                 {
1742                   bmp_subtype=ARGB1555;
1743                   bmp_info.red_mask=0x00007c00U;
1744                   bmp_info.green_mask=0x000003e0U;
1745                   bmp_info.blue_mask=0x0000001fU;
1746                   bmp_info.alpha_mask=0x00008000U;
1747                 }
1748             }
1749           else
1750           {
1751             if (LocaleNCompare(option,"RGB555",6) == 0)
1752               {
1753                 bmp_subtype=RGB555;
1754                 bmp_info.red_mask=0x00007c00U;
1755                 bmp_info.green_mask=0x000003e0U;
1756                 bmp_info.blue_mask=0x0000001fU;
1757                 bmp_info.alpha_mask=0U;
1758               }
1759             else if (LocaleNCompare(option,"RGB565",6) == 0)
1760               {
1761                 bmp_subtype=RGB565;
1762                 bmp_info.red_mask=0x0000f800U;
1763                 bmp_info.green_mask=0x000007e0U;
1764                 bmp_info.blue_mask=0x0000001fU;
1765                 bmp_info.alpha_mask=0U;
1766               }
1767           }
1768         }
1769         if (bmp_subtype != UndefinedSubtype)
1770           {
1771             bmp_info.bits_per_pixel=16;
1772             bmp_info.compression=BI_BITFIELDS;
1773           }
1774         else
1775           {
1776             bmp_info.bits_per_pixel=(unsigned short) ((type > 3) &&
1777                (image->alpha_trait != UndefinedPixelTrait) ? 32 : 24);
1778             bmp_info.compression=(unsigned int) ((type > 3) &&
1779               (image->alpha_trait != UndefinedPixelTrait) ? BI_BITFIELDS : BI_RGB);
1780             if ((type == 3) && (image->alpha_trait != UndefinedPixelTrait))
1781               {
1782                 option=GetImageOption(image_info,"bmp3:alpha");
1783                 if (IsStringTrue(option))
1784                   bmp_info.bits_per_pixel=32;
1785               }
1786           }
1787       }
1788     bytes_per_line=4*((image->columns*bmp_info.bits_per_pixel+31)/32);
1789     bmp_info.ba_offset=0;
1790     profile=GetImageProfile(image,"icc");
1791     have_color_info=(image->rendering_intent != UndefinedIntent) ||
1792       (profile != (StringInfo *) NULL) || (image->gamma != 0.0) ?  MagickTrue :
1793       MagickFalse;
1794     if (type == 2)
1795       bmp_info.size=12;
1796     else
1797       if ((type == 3) || ((image->alpha_trait == UndefinedPixelTrait) &&
1798           (have_color_info == MagickFalse)))
1799         {
1800           type=3;
1801           bmp_info.size=40;
1802         }
1803       else
1804         {
1805           int
1806             extra_size;
1807
1808           bmp_info.size=108;
1809           extra_size=68;
1810           if ((image->rendering_intent != UndefinedIntent) ||
1811               (profile != (StringInfo *) NULL))
1812             {
1813               bmp_info.size=124;
1814               extra_size+=16;
1815             }
1816           bmp_info.file_size+=extra_size;
1817           bmp_info.offset_bits+=extra_size;
1818         }
1819     if (((ssize_t) image->columns != (ssize_t) ((signed int) image->columns)) ||
1820         ((ssize_t) image->rows != (ssize_t) ((signed int) image->rows)))
1821       ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
1822     bmp_info.width=(ssize_t) image->columns;
1823     bmp_info.height=(ssize_t) image->rows;
1824     bmp_info.planes=1;
1825     bmp_info.image_size=(unsigned int) (bytes_per_line*image->rows);
1826     bmp_info.file_size+=bmp_info.image_size;
1827     bmp_info.x_pixels=75*39;
1828     bmp_info.y_pixels=75*39;
1829     switch (image->units)
1830     {
1831       case UndefinedResolution:
1832       case PixelsPerInchResolution:
1833       {
1834         bmp_info.x_pixels=(unsigned int) (100.0*image->resolution.x/2.54);
1835         bmp_info.y_pixels=(unsigned int) (100.0*image->resolution.y/2.54);
1836         break;
1837       }
1838       case PixelsPerCentimeterResolution:
1839       {
1840         bmp_info.x_pixels=(unsigned int) (100.0*image->resolution.x);
1841         bmp_info.y_pixels=(unsigned int) (100.0*image->resolution.y);
1842         break;
1843       }
1844     }
1845     bmp_info.colors_important=bmp_info.number_colors;
1846     /*
1847       Convert MIFF to BMP raster pixels.
1848     */
1849     pixel_info=AcquireVirtualMemory(image->rows,
1850       MagickMax(bytes_per_line,image->columns+256UL)*sizeof(*pixels));
1851     if (pixel_info == (MemoryInfo *) NULL)
1852       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1853     pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);
1854     (void) memset(pixels,0,(size_t) bmp_info.image_size);
1855     switch (bmp_info.bits_per_pixel)
1856     {
1857       case 1:
1858       {
1859         size_t
1860           bit,
1861           byte;
1862
1863         /*
1864           Convert PseudoClass image to a BMP monochrome image.
1865         */
1866         for (y=0; y < (ssize_t) image->rows; y++)
1867         {
1868           ssize_t
1869             offset;
1870
1871           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1872           if (p == (const Quantum *) NULL)
1873             break;
1874           q=pixels+(image->rows-y-1)*bytes_per_line;
1875           bit=0;
1876           byte=0;
1877           for (x=0; x < (ssize_t) image->columns; x++)
1878           {
1879             byte<<=1;
1880             byte|=GetPixelIndex(image,p) != 0 ? 0x01 : 0x00;
1881             bit++;
1882             if (bit == 8)
1883               {
1884                 *q++=(unsigned char) byte;
1885                 bit=0;
1886                 byte=0;
1887               }
1888              p+=GetPixelChannels(image);
1889            }
1890            if (bit != 0)
1891              {
1892                *q++=(unsigned char) (byte << (8-bit));
1893                x++;
1894              }
1895           offset=(ssize_t) (image->columns+7)/8;
1896           for (x=offset; x < (ssize_t) bytes_per_line; x++)
1897             *q++=0x00;
1898           if (image->previous == (Image *) NULL)
1899             {
1900               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1901                 image->rows);
1902               if (status == MagickFalse)
1903                 break;
1904             }
1905         }
1906         break;
1907       }
1908       case 4:
1909       {
1910         unsigned int
1911           byte,
1912           nibble;
1913
1914         ssize_t
1915           offset;
1916
1917         /*
1918           Convert PseudoClass image to a BMP monochrome image.
1919         */
1920         for (y=0; y < (ssize_t) image->rows; y++)
1921         {
1922           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1923           if (p == (const Quantum *) NULL)
1924             break;
1925           q=pixels+(image->rows-y-1)*bytes_per_line;
1926           nibble=0;
1927           byte=0;
1928           for (x=0; x < (ssize_t) image->columns; x++)
1929           {
1930             byte<<=4;
1931             byte|=((unsigned int) GetPixelIndex(image,p) & 0x0f);
1932             nibble++;
1933             if (nibble == 2)
1934               {
1935                 *q++=(unsigned char) byte;
1936                 nibble=0;
1937                 byte=0;
1938               }
1939             p+=GetPixelChannels(image);
1940           }
1941           if (nibble != 0)
1942             {
1943               *q++=(unsigned char) (byte << 4);
1944               x++;
1945             }
1946           offset=(ssize_t) (image->columns+1)/2;
1947           for (x=offset; x < (ssize_t) bytes_per_line; x++)
1948             *q++=0x00;
1949           if (image->previous == (Image *) NULL)
1950             {
1951               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1952                 image->rows);
1953               if (status == MagickFalse)
1954                 break;
1955             }
1956         }
1957         break;
1958       }
1959       case 8:
1960       {
1961         /*
1962           Convert PseudoClass packet to BMP pixel.
1963         */
1964         for (y=0; y < (ssize_t) image->rows; y++)
1965         {
1966           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1967           if (p == (const Quantum *) NULL)
1968             break;
1969           q=pixels+(image->rows-y-1)*bytes_per_line;
1970           for (x=0; x < (ssize_t) image->columns; x++)
1971           {
1972             *q++=(unsigned char) GetPixelIndex(image,p);
1973             p+=GetPixelChannels(image);
1974           }
1975           for ( ; x < (ssize_t) bytes_per_line; x++)
1976             *q++=0x00;
1977           if (image->previous == (Image *) NULL)
1978             {
1979               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1980                 image->rows);
1981               if (status == MagickFalse)
1982                 break;
1983             }
1984         }
1985         break;
1986       }
1987       case 16:
1988       {
1989         /*
1990           Convert DirectClass packet to BMP BGR888.
1991         */
1992         for (y=0; y < (ssize_t) image->rows; y++)
1993         {
1994           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1995           if (p == (const Quantum *) NULL)
1996             break;
1997           q=pixels+(image->rows-y-1)*bytes_per_line;
1998           for (x=0; x < (ssize_t) image->columns; x++)
1999           {
2000             unsigned short
2001               pixel;
2002
2003             pixel=0;
2004             if (bmp_subtype == ARGB4444)
2005               {
2006                 pixel=(unsigned short) (ScaleQuantumToAny(
2007                   GetPixelAlpha(image,p),15) << 12);
2008                 pixel|=(unsigned short) (ScaleQuantumToAny(
2009                   GetPixelRed(image,p),15) << 8);
2010                 pixel|=(unsigned short) (ScaleQuantumToAny(
2011                   GetPixelGreen(image,p),15) << 4);
2012                 pixel|=(unsigned short) (ScaleQuantumToAny(
2013                   GetPixelBlue(image,p),15));
2014               }
2015             else if (bmp_subtype == RGB565)
2016               {
2017                 pixel=(unsigned short) (ScaleQuantumToAny(
2018                   GetPixelRed(image,p),31) << 11);
2019                 pixel|=(unsigned short) (ScaleQuantumToAny(
2020                   GetPixelGreen(image,p),63) << 5);
2021                 pixel|=(unsigned short) (ScaleQuantumToAny(
2022                   GetPixelBlue(image,p),31));
2023               }
2024             else
2025               {
2026                 if (bmp_subtype == ARGB1555)
2027                   pixel=(unsigned short) (ScaleQuantumToAny(
2028                     GetPixelAlpha(image,p),1) << 15);
2029                 pixel|=(unsigned short) (ScaleQuantumToAny(
2030                   GetPixelRed(image,p),31) << 10);
2031                 pixel|=(unsigned short) (ScaleQuantumToAny(
2032                   GetPixelGreen(image,p),31) << 5);
2033                 pixel|=(unsigned short) (ScaleQuantumToAny(
2034                   GetPixelBlue(image,p),31));
2035               }
2036             *((unsigned short *) q)=pixel;
2037             q+=2;
2038             p+=GetPixelChannels(image);
2039           }
2040           for (x=2L*(ssize_t) image->columns; x < (ssize_t) bytes_per_line; x++)
2041             *q++=0x00;
2042           if (image->previous == (Image *) NULL)
2043             {
2044               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
2045                 image->rows);
2046               if (status == MagickFalse)
2047                 break;
2048             }
2049         }
2050         break;
2051       }
2052       case 24:
2053       {
2054         /*
2055           Convert DirectClass packet to BMP BGR888.
2056         */
2057         for (y=0; y < (ssize_t) image->rows; y++)
2058         {
2059           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
2060           if (p == (const Quantum *) NULL)
2061             break;
2062           q=pixels+(image->rows-y-1)*bytes_per_line;
2063           for (x=0; x < (ssize_t) image->columns; x++)
2064           {
2065             *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
2066             *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
2067             *q++=ScaleQuantumToChar(GetPixelRed(image,p));
2068             p+=GetPixelChannels(image);
2069           }
2070           for (x=3L*(ssize_t) image->columns; x < (ssize_t) bytes_per_line; x++)
2071             *q++=0x00;
2072           if (image->previous == (Image *) NULL)
2073             {
2074               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
2075                 image->rows);
2076               if (status == MagickFalse)
2077                 break;
2078             }
2079         }
2080         break;
2081       }
2082       case 32:
2083       {
2084         /*
2085           Convert DirectClass packet to ARGB8888 pixel.
2086         */
2087         for (y=0; y < (ssize_t) image->rows; y++)
2088         {
2089           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
2090           if (p == (const Quantum *) NULL)
2091             break;
2092           q=pixels+(image->rows-y-1)*bytes_per_line;
2093           for (x=0; x < (ssize_t) image->columns; x++)
2094           {
2095             *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
2096             *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
2097             *q++=ScaleQuantumToChar(GetPixelRed(image,p));
2098             *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
2099             p+=GetPixelChannels(image);
2100           }
2101           if (image->previous == (Image *) NULL)
2102             {
2103               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
2104                 image->rows);
2105               if (status == MagickFalse)
2106                 break;
2107             }
2108         }
2109         break;
2110       }
2111     }
2112     if ((type > 2) && (bmp_info.bits_per_pixel == 8))
2113       if (image_info->compression != NoCompression)
2114         {
2115           MemoryInfo
2116             *rle_info;
2117
2118           /*
2119             Convert run-length encoded raster pixels.
2120           */
2121           rle_info=AcquireVirtualMemory((size_t) (2*(bytes_per_line+2)+2),
2122             (image->rows+2)*sizeof(*pixels));
2123           if (rle_info == (MemoryInfo *) NULL)
2124             {
2125               pixel_info=RelinquishVirtualMemory(pixel_info);
2126               ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
2127             }
2128           bmp_data=(unsigned char *) GetVirtualMemoryBlob(rle_info);
2129           bmp_info.file_size-=bmp_info.image_size;
2130           bmp_info.image_size=(unsigned int) EncodeImage(image,bytes_per_line,
2131             pixels,bmp_data);
2132           bmp_info.file_size+=bmp_info.image_size;
2133           pixel_info=RelinquishVirtualMemory(pixel_info);
2134           pixel_info=rle_info;
2135           pixels=bmp_data;
2136           bmp_info.compression=BI_RLE8;
2137         }
2138     /*
2139       Write BMP for Windows, all versions, 14-byte header.
2140     */
2141     if (image->debug != MagickFalse)
2142       {
2143         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2144           "   Writing BMP version %.20g datastream",(double) type);
2145         if (image->storage_class == DirectClass)
2146           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2147             "   Storage class=DirectClass");
2148         else
2149           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2150             "   Storage class=PseudoClass");
2151         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2152           "   Image depth=%.20g",(double) image->depth);
2153         if (image->alpha_trait != UndefinedPixelTrait)
2154           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2155             "   Matte=True");
2156         else
2157           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2158             "   Matte=MagickFalse");
2159         (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2160           "   BMP bits_per_pixel=%.20g",(double) bmp_info.bits_per_pixel);
2161         switch ((int) bmp_info.compression)
2162         {
2163            case BI_RGB:
2164            {
2165              (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2166                "   Compression=BI_RGB");
2167              break;
2168            }
2169            case BI_RLE8:
2170            {
2171              (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2172                "   Compression=BI_RLE8");
2173              break;
2174            }
2175            case BI_BITFIELDS:
2176            {
2177              (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2178                "   Compression=BI_BITFIELDS");
2179              break;
2180            }
2181            default:
2182            {
2183              (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2184                "   Compression=UNKNOWN (%u)",bmp_info.compression);
2185              break;
2186            }
2187         }
2188         if (bmp_info.number_colors == 0)
2189           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2190             "   Number_colors=unspecified");
2191         else
2192           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2193             "   Number_colors=%u",bmp_info.number_colors);
2194       }
2195     (void) WriteBlob(image,2,(unsigned char *) "BM");
2196     (void) WriteBlobLSBLong(image,bmp_info.file_size);
2197     (void) WriteBlobLSBLong(image,bmp_info.ba_offset);  /* always 0 */
2198     (void) WriteBlobLSBLong(image,bmp_info.offset_bits);
2199     if (type == 2)
2200       {
2201         /*
2202           Write 12-byte version 2 bitmap header.
2203         */
2204         (void) WriteBlobLSBLong(image,bmp_info.size);
2205         (void) WriteBlobLSBSignedShort(image,(signed short) bmp_info.width);
2206         (void) WriteBlobLSBSignedShort(image,(signed short) bmp_info.height);
2207         (void) WriteBlobLSBShort(image,bmp_info.planes);
2208         (void) WriteBlobLSBShort(image,bmp_info.bits_per_pixel);
2209       }
2210     else
2211       {
2212         /*
2213           Write 40-byte version 3+ bitmap header.
2214         */
2215         (void) WriteBlobLSBLong(image,bmp_info.size);
2216         (void) WriteBlobLSBSignedLong(image,(signed int) bmp_info.width);
2217         (void) WriteBlobLSBSignedLong(image,(signed int) bmp_info.height);
2218         (void) WriteBlobLSBShort(image,bmp_info.planes);
2219         (void) WriteBlobLSBShort(image,bmp_info.bits_per_pixel);
2220         (void) WriteBlobLSBLong(image,bmp_info.compression);
2221         (void) WriteBlobLSBLong(image,bmp_info.image_size);
2222         (void) WriteBlobLSBLong(image,bmp_info.x_pixels);
2223         (void) WriteBlobLSBLong(image,bmp_info.y_pixels);
2224         (void) WriteBlobLSBLong(image,bmp_info.number_colors);
2225         (void) WriteBlobLSBLong(image,bmp_info.colors_important);
2226       }
2227     if ((type > 3) && ((image->alpha_trait != UndefinedPixelTrait) ||
2228         (have_color_info != MagickFalse)))
2229       {
2230         /*
2231           Write the rest of the 108-byte BMP Version 4 header.
2232         */
2233         (void) WriteBlobLSBLong(image,bmp_info.red_mask);
2234         (void) WriteBlobLSBLong(image,bmp_info.green_mask);
2235         (void) WriteBlobLSBLong(image,bmp_info.blue_mask);
2236         (void) WriteBlobLSBLong(image,bmp_info.alpha_mask);
2237         (void) WriteBlobLSBLong(image,0x73524742U);  /* sRGB */
2238         (void) WriteBlobLSBLong(image,(unsigned int)
2239           (image->chromaticity.red_primary.x*0x40000000));
2240         (void) WriteBlobLSBLong(image,(unsigned int)
2241           (image->chromaticity.red_primary.y*0x40000000));
2242         (void) WriteBlobLSBLong(image,(unsigned int)
2243           ((1.000f-(image->chromaticity.red_primary.x+
2244           image->chromaticity.red_primary.y))*0x40000000));
2245         (void) WriteBlobLSBLong(image,(unsigned int)
2246           (image->chromaticity.green_primary.x*0x40000000));
2247         (void) WriteBlobLSBLong(image,(unsigned int)
2248           (image->chromaticity.green_primary.y*0x40000000));
2249         (void) WriteBlobLSBLong(image,(unsigned int)
2250           ((1.000f-(image->chromaticity.green_primary.x+
2251           image->chromaticity.green_primary.y))*0x40000000));
2252         (void) WriteBlobLSBLong(image,(unsigned int)
2253           (image->chromaticity.blue_primary.x*0x40000000));
2254         (void) WriteBlobLSBLong(image,(unsigned int)
2255           (image->chromaticity.blue_primary.y*0x40000000));
2256         (void) WriteBlobLSBLong(image,(unsigned int)
2257           ((1.000f-(image->chromaticity.blue_primary.x+
2258           image->chromaticity.blue_primary.y))*0x40000000));
2259         (void) WriteBlobLSBLong(image,(unsigned int)
2260           (bmp_info.gamma_scale.x*0x10000));
2261         (void) WriteBlobLSBLong(image,(unsigned int)
2262           (bmp_info.gamma_scale.y*0x10000));
2263         (void) WriteBlobLSBLong(image,(unsigned int)
2264           (bmp_info.gamma_scale.z*0x10000));
2265         if ((image->rendering_intent != UndefinedIntent) ||
2266             (profile != (StringInfo *) NULL))
2267           {
2268             ssize_t
2269               intent;
2270
2271             switch ((int) image->rendering_intent)
2272             {
2273               case SaturationIntent:
2274               {
2275                 intent=LCS_GM_BUSINESS;
2276                 break;
2277               }
2278               case RelativeIntent:
2279               {
2280                 intent=LCS_GM_GRAPHICS;
2281                 break;
2282               }
2283               case PerceptualIntent:
2284               {
2285                 intent=LCS_GM_IMAGES;
2286                 break;
2287               }
2288               case AbsoluteIntent:
2289               {
2290                 intent=LCS_GM_ABS_COLORIMETRIC;
2291                 break;
2292               }
2293               default:
2294               {
2295                 intent=0;
2296                 break;
2297               }
2298             }
2299             (void) WriteBlobLSBLong(image,(unsigned int) intent);
2300             (void) WriteBlobLSBLong(image,0x00);  /* dummy profile data */
2301             (void) WriteBlobLSBLong(image,0x00);  /* dummy profile length */
2302             (void) WriteBlobLSBLong(image,0x00);  /* reserved */
2303           }
2304       }
2305     if (image->storage_class == PseudoClass)
2306       {
2307         unsigned char
2308           *bmp_colormap;
2309
2310         /*
2311           Dump colormap to file.
2312         */
2313         if (image->debug != MagickFalse)
2314           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2315             "  Colormap: %.20g entries",(double) image->colors);
2316         bmp_colormap=(unsigned char *) AcquireQuantumMemory((size_t) (1UL <<
2317           bmp_info.bits_per_pixel),4*sizeof(*bmp_colormap));
2318         if (bmp_colormap == (unsigned char *) NULL)
2319           ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
2320         q=bmp_colormap;
2321         for (i=0; i < (ssize_t) MagickMin((ssize_t) image->colors,(ssize_t) bmp_info.number_colors); i++)
2322         {
2323           *q++=ScaleQuantumToChar(ClampToQuantum(image->colormap[i].blue));
2324           *q++=ScaleQuantumToChar(ClampToQuantum(image->colormap[i].green));
2325           *q++=ScaleQuantumToChar(ClampToQuantum(image->colormap[i].red));
2326           if (type > 2)
2327             *q++=(unsigned char) 0x0;
2328         }
2329         for ( ; i < (ssize_t) (1UL << bmp_info.bits_per_pixel); i++)
2330         {
2331           *q++=(unsigned char) 0x00;
2332           *q++=(unsigned char) 0x00;
2333           *q++=(unsigned char) 0x00;
2334           if (type > 2)
2335             *q++=(unsigned char) 0x00;
2336         }
2337         if (type <= 2)
2338           (void) WriteBlob(image,(size_t) (3*(1L << bmp_info.bits_per_pixel)),
2339             bmp_colormap);
2340         else
2341           (void) WriteBlob(image,(size_t) (4*(1L << bmp_info.bits_per_pixel)),
2342             bmp_colormap);
2343         bmp_colormap=(unsigned char *) RelinquishMagickMemory(bmp_colormap);
2344       }
2345     if (image->debug != MagickFalse)
2346       (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2347         "  Pixels:  %u bytes",bmp_info.image_size);
2348     (void) WriteBlob(image,(size_t) bmp_info.image_size,pixels);
2349     pixel_info=RelinquishVirtualMemory(pixel_info);
2350     if (GetNextImageInList(image) == (Image *) NULL)
2351       break;
2352     image=SyncNextImageInList(image);
2353     status=SetImageProgress(image,SaveImagesTag,scene++,imageListLength);
2354     if (status == MagickFalse)
2355       break;
2356   } while (image_info->adjoin != MagickFalse);
2357   (void) CloseBlob(image);
2358   return(MagickTrue);
2359 }