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

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