/*

% Copyright (C) 2003-2024 GraphicsMagick Group

% Copyright (C) 2002 ImageMagick Studio

% Copyright 1991-1999 E. I. du Pont de Nemours and Company

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                            BBBB   M   M  PPPP                               %

%                            B   B  MM MM  P   P                              %

%                            BBBB   M M M  PPPP                               %

%                            B   B  M   M  P                                  %

%                            BBBB   M   M  P                                  %

%                                                                             %

%                                                                             %

%             Read/Write Microsoft Windows Bitmap Image Format.               %

%                                                                             %

%                                                                             %

%                              Software Design                                %

%                                John Cristy                                  %

%                            Glenn Randers-Pehrson                            %

%                               December 2001                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/blob.h"

#include "magick/colormap.h"

#include "magick/constitute.h"

#include "magick/enum_strings.h"

#include "magick/log.h"

#include "magick/magick.h"

#include "magick/monitor.h"

#include "magick/pixel_cache.h"

#include "magick/profile.h"

#include "magick/transform.h"

#include "magick/utility.h"

/*

  Macro definitions (from Windows wingdi.h).

*/

#undef BI_JPEG

#define BI_JPEG  4

#undef BI_PNG

#define BI_PNG  5

#ifndef BI_ALPHABITFIELDS

 #define BI_ALPHABITFIELDS 6

#endif

#if !defined(MSWINDOWS) || defined(__MINGW32__)

#undef BI_RGB

#define BI_RGB  0

#undef BI_RLE8

#define BI_RLE8  1

#undef BI_RLE4

#define BI_RLE4  2

#undef BI_BITFIELDS

#define BI_BITFIELDS  3

#undef LCS_CALIBRATED_RGB

#define LCS_CALIBRATED_RGB  0

#undef LCS_sRGB

#define LCS_sRGB  1

#undef LCS_WINDOWS_COLOR_SPACE

#define LCS_WINDOWS_COLOR_SPACE  2

#undef PROFILE_LINKED

#define PROFILE_LINKED  3

#undef PROFILE_EMBEDDED

#define PROFILE_EMBEDDED  4

#undef LCS_GM_BUSINESS

#define LCS_GM_BUSINESS  1  /* Saturation */

#undef LCS_GM_GRAPHICS

#define LCS_GM_GRAPHICS  2  /* Relative */

#undef LCS_GM_IMAGES

#define LCS_GM_IMAGES  4  /* Perceptual */

#undef LCS_GM_ABS_COLORIMETRIC

#define LCS_GM_ABS_COLORIMETRIC  8  /* Absolute */

#endif /* !defined(MSWINDOWS) || defined(__MINGW32__) */

#if (QuantumDepth == 8)

  #define MS_VAL16_TO_QUANTUM(_value)   ((_value>=8192)?255:(_value>>5))

#elif (QuantumDepth == 16)

  #define MS_VAL16_TO_QUANTUM(_value)   ((_value>=8192)?65535:(_value*8))

#elif (QuantumDepth == 32)

  #define MS_VAL16_TO_QUANTUM(_value)   ((_value>=8192)?4294443007:(_value*524288))

#else

# error Unsupported quantum depth.

#endif

#ifdef WORDS_BIGENDIAN

  #define LD_UINT16_LSB(_pixel, _ptr) _pixel=(magick_uint16_t)*_ptr++; _pixel|=(magick_uint16_t)*_ptr++ << 8

#else

  #define LD_UINT16_LSB(_pixel, _ptr) _pixel=*(magick_uint16_t*)_ptr; _ptr+=2

#endif

/*

  Typedef declarations.

*/

typedef struct _BMPInfo

{

  size_t

    file_size,  /* 0 or size of file in bytes */

    image_size; /* bytes_per_line*image->rows or uint32_t from file */

  magick_uint32_t

    ba_offset,

    offset_bits,/* Starting position of image data in bytes */

    size;       /* Header size 12 = v2, 12-64 OS/2 v2, 40 = v3, 108 = v4, 124 = v5 */

  magick_int32_t

    width,      /* BMP width */

    height;     /* BMP height (negative means bottom-up) */

  magick_uint16_t

    planes,

    bits_per_pixel;

  magick_uint32_t

    compression,

    x_pixels,

    y_pixels,

    number_colors,

    colors_important;

  magick_uint32_t

    red_mask,

    green_mask,

    blue_mask,

    alpha_mask;

  magick_int32_t

    colorspace;

  PrimaryInfo

    red_primary,

    green_primary,

    blue_primary,

    gamma_scale;

} BMPInfo;

/*

  Forward declarations.

*/

static unsigned int

  WriteBMPImage(const ImageInfo *,Image *);

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   D e c o d e I m a g e                                                     %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method DecodeImage unpacks the packed image pixels into runlength-encoded

%  pixel packets.

%

%  The format of the DecodeImage method is:

%

%      MagickPassFail DecodeImage(Image *image,const unsigned long compression,

%        unsigned char *pixels)

%

%  A description of each parameter follows:

%

%    o status:  Method DecodeImage returns MagickPass if all the pixels are

%      uncompressed without error, otherwise MagickFail.

%

%    o image: The address of a structure of type Image.

%

%    o compression:  Zero means uncompressed.  A value of 1 means the

%      compressed pixels are runlength encoded for a 256-color bitmap.

%      A value of 2 means a 16-color bitmap.  A value of 3 means bitfields

%      encoding.

%

%    o pixels:  The address of a byte (8 bits) array of pixel data created by

%      the decoding process.

%

%    o pixels_size: The size of the allocated buffer array.

%

*/

static MagickPassFail DecodeImage(Image *image,const unsigned long compression,

                                  unsigned char *pixels, const size_t pixels_size)

{

  unsigned long

    x,

    y;

  unsigned int

    i;

  int

    byte,

    count;

  register unsigned char

    *q;

  unsigned char

    *end;

  assert(image != (Image *) NULL);

  assert(pixels != (unsigned char *) NULL);

  if (image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "  Decoding RLE compressed pixels to"

                          " %" MAGICK_SIZE_T_F "u bytes",

                          (MAGICK_SIZE_T ) image->rows*image->columns);

  (void) memset(pixels,0,pixels_size);

  byte=0;

  x=0;

  q=pixels;

  end=pixels + pixels_size;

  /*

    Decompress sufficient data to support the number of pixels (or

    rows) in the image and then return.

    Do not wait to read the final EOL and EOI markers (if not yet

    encountered) since we always read this marker just before we

    return.

  */

  for (y=0; y < image->rows; )

    {

      if (q < pixels || q >= end)

        {

          if (image->logging)

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "  Decode buffer full (y=%lu, "

                                  "pixels_size=%" MAGICK_SIZE_T_F "u, "

                                  "pixels=%p, q=%p, end=%p)",

                                  y, (MAGICK_SIZE_T) pixels_size,

                                  pixels, q, end);

          break;

        }

      count=ReadBlobByte(image);

      if (count == EOF)

        return MagickFail;

      if (count > 0)

        {

          count=Min(count, end - q);

          /*

            Encoded mode.

          */

          byte=ReadBlobByte(image);

          if (byte == EOF)

            return MagickFail;

          if (compression == BI_RLE8)

            {

              for ( i=count; i != 0; --i )

                {

                  *q++=(unsigned char) byte;

                }

            }

          else

            {

              for ( i=0; i < (unsigned int) count; i++ )

                {

                  *q++=(unsigned char)

                    ((i & 0x01) ? (byte & 0x0f) : ((byte >> 4) & 0x0f));

                }

            }

          x+=count;

        }

      else

        {

          /*

            Escape mode.

          */

          count=ReadBlobByte(image);

          if (count == EOF)

            return MagickFail;

          if (count == 0x01)

            {

              if (image->logging)

                (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                      "  RLE Escape code encountered");

              goto rle_decode_done;

            }

          switch (count)

            {

            case 0x00:

              {

                /*

                  End of line.

                */

                x=0;

                y++;

                q=pixels+y*(size_t) image->columns;

                break;

              }

            case 0x02:

              {

                /*

                  Delta mode.

                */

                byte=ReadBlobByte(image);

                if (byte == EOF)

                  return MagickFail;

                x+=byte;

                byte=ReadBlobByte(image);

                if (byte == EOF)

                  return MagickFail;

                y+=byte;

                q=pixels+y*(size_t) image->columns+x;

                break;

              }

            default:

              {

                /*

                  Absolute mode.

                */

                count=Min(count, end - q);

                if (count < 0)

                  return MagickFail;

                if (compression == BI_RLE8)

                  for (i=count; i != 0; --i)

                    {

                      byte=ReadBlobByte(image);

                      if (byte == EOF)

                        return MagickFail;

                      *q++=byte;

                    }

                else

                  for (i=0; i < (unsigned int) count; i++)

                    {

                      if ((i & 0x01) == 0)

                        {

                          byte=ReadBlobByte(image);

                          if (byte == EOF)

                            return MagickFail;

                        }

                      *q++=(unsigned char)

                        ((i & 0x01) ? (byte & 0x0f) : ((byte >> 4) & 0x0f));

                    }

                x+=count;

                /*

                  Read pad byte.

                */

                if (compression == BI_RLE8)

                  {

                    if (count & 0x01)

                      if (ReadBlobByte(image) == EOF)

                        return MagickFail;

                  }

                else

                  if (((count & 0x03) == 1) || ((count & 0x03) == 2))

                    if (ReadBlobByte(image) == EOF)

                      return MagickFail;

                break;

              }

            }

        }

      if (QuantumTick(y,image->rows))

        if (!MagickMonitorFormatted(y,image->rows,&image->exception,

                                    LoadImageText,image->filename,

                                    image->columns,image->rows))

          break;

    }

  (void) ReadBlobByte(image);  /* end of line */

  (void) ReadBlobByte(image);

 rle_decode_done:

  if (image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "  Decoded %" MAGICK_SIZE_T_F "u bytes",

                          (MAGICK_SIZE_T) (q-pixels));

  if ((MAGICK_SIZE_T) (q-pixels) < pixels_size)

    {

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "  RLE decoded output is truncated");

      return MagickFail;

    }

  return(MagickPass);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   E n c o d e I m a g e                                                     %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method EncodeImage compresses pixels using a runlength encoded format.

%

%  The format of the EncodeImage method is:

%

%    static unsigned int EncodeImage(Image *image,

%      const unsigned long bytes_per_line,const unsigned char *pixels,

%      unsigned char *compressed_pixels)

%

%  A description of each parameter follows:

%

%    o status:  Method EncodeImage returns the number of bytes in the

%      runlength encoded compress_pixels array.

%

%    o image:  A pointer to an Image structure.

%

%    o bytes_per_line: The number of bytes in a scanline of compressed pixels

%

%    o pixels:  The address of a byte (8 bits) array of pixel data created by

%      the compression process.

%

%    o compressed_pixels:  The address of a byte (8 bits) array of compressed

%      pixel data.

%

%

*/

static size_t EncodeImage(Image *image,const size_t bytes_per_line,

  const unsigned char *pixels,unsigned char *compressed_pixels)

{

  unsigned long

    y;

  register const unsigned char

    *p;

  register unsigned long

    i,

    x;

  register unsigned char

    *q;

  /*

    Runlength encode pixels.

  */

  assert(image != (Image *) NULL);

  assert(pixels != (const unsigned char *) NULL);

  assert(compressed_pixels != (unsigned char *) NULL);

  p=pixels;

  q=compressed_pixels;

  i=0;

  for (y=0; y < image->rows; y++)

  {

    for (x=0; x < bytes_per_line; x+=i)

    {

      /*

        Determine runlength.

      */

      for (i=1; (((size_t) x+i) < bytes_per_line); i++)

        if ((i == 255) || (*(p+i) != *p))

          break;

      *q++=(unsigned char) i;

      *q++=(*p);

      p+=i;

    }

    /*

      End of line.

    */

    *q++=0x00;

    *q++=0x00;

    if (QuantumTick(y,image->rows))

      if (!MagickMonitorFormatted(y,image->rows,&image->exception,

                                  SaveImageText,image->filename,

                                  image->columns,image->rows))

        break;

  }

  /*

    End of bitmap.

  */

  *q++=0;

  *q++=0x01;

  return((size_t) (q-compressed_pixels));

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   I s B M P                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method IsBMP returns MagickTrue if the image format type, identified by the

%  magick string, is BMP.

%

%  The format of the IsBMP method is:

%

%      unsigned int IsBMP(const unsigned char *magick,const size_t length)

%

%  A description of each parameter follows:

%

%    o status:  Method IsBMP returns MagickTrue if the image format type is BMP.

%

%    o magick: This string is generally the first few bytes of an image file

%      or blob.

%

%    o length: Specifies the length of the magick string.

%

%

*/

static unsigned int IsBMP(const unsigned char *magick,const size_t length)

{

  if (length < 2)

    return(MagickFalse);

  if ((LocaleNCompare((char *) magick,"BA",2) == 0) ||

      (LocaleNCompare((char *) magick,"BM",2) == 0) ||

      (LocaleNCompare((char *) magick,"IC",2) == 0) ||

      (LocaleNCompare((char *) magick,"PI",2) == 0) ||

      (LocaleNCompare((char *) magick,"CI",2) == 0) ||

      (LocaleNCompare((char *) magick,"CP",2) == 0))

    return(MagickTrue);

  return(MagickFalse);

}

static const char *DecodeBiCompression(const magick_uint32_t BiCompression, const magick_uint32_t BiSize)

{

  switch(BiCompression)

  {

    case BI_RGB:  return "BI_RGB";      /* uncompressed */

    case BI_RLE4: return "BI_RLE4";     /* 4 bit RLE */

    case BI_RLE8: return "BI_RLE8";     /* 8 bit RLE */

    case BI_BITFIELDS:

                  if(BiSize==64) return "OS/2 Huffman 1D";

                            else return "BI_BITFIELDS";

    case BI_JPEG: if(BiSize==64) return "OS/2 RLE-24";

                            else return "BI_JPEG";

    case BI_PNG: return  "BI_PNG";

    case BI_ALPHABITFIELDS: return "BI_ALPHABITFIELDS";

  }

  return "UNKNOWN";

}

static Image *ExtractNestedBlob(Image ** image, const ImageInfo * image_info, int ImgType, ExceptionInfo * exception)

{

  size_t

    alloc_size;

  unsigned char

    *blob;

  alloc_size = GetBlobSize(*image) - TellBlob(*image);

  if (alloc_size > 0 &&

      (blob = MagickAllocateResourceLimitedMemory(unsigned char *,alloc_size)) != NULL)

    {

      /* Copy JPG to memory blob */

      if (ReadBlob(*image,alloc_size,blob) == alloc_size)

        {

          Image *image2;

          ImageInfo *clone_info;

          clone_info = CloneImageInfo(image_info);

          (void) strlcpy(clone_info->magick, (ImgType==BI_JPEG)?"JPEG":"PNG", sizeof(clone_info->magick));

          /* BlobToFile("/tmp/jnx-tile.jpg", blob,alloc_size,exception); */

          /* (void) strlcpy(clone_info->filename, (ImgType==BI_JPEG)?"JPEG:":"PNG:", sizeof(clone_info->filename)); */

          FormatString(clone_info->filename,"%sblob-%px", ImgType==BI_JPEG?"JPEG:":"PNG:", blob);

          if ((image2 = BlobToImage(clone_info,blob,alloc_size,exception))

              != NULL)

            {

              if ((*image)->logging)

                (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                      "Read embedded %s blob with dimensions %lux%lu",

                                      image2->magick, image2->rows, image2->columns);

              /*

                Replace current image with new image while copying

                base image attributes.

              */

              (void) strlcpy(image2->filename, (*image)->filename,

                             sizeof(image2->filename));

            (void) strlcpy(image2->magick_filename, (*image)->magick_filename,

                           sizeof(image2->magick_filename));

            (void) strlcpy(image2->magick, (*image)->magick,

                           sizeof(image2->magick));

            DestroyBlob(image2);

            image2->blob = ReferenceBlob((*image)->blob);

            if(((*image)->rows == 0) || ((*image)->columns == 0))

                DeleteImageFromList(image);

            AppendImageToList(image, image2);

         }

          DestroyImageInfo(clone_info);

          clone_info = (ImageInfo *) NULL;

          MagickFreeResourceLimitedMemory(blob);

        }

      else

        {

          MagickFreeResourceLimitedMemory(blob);

          /* Failed to read enough data from input */

          ThrowException(exception,CorruptImageError,UnexpectedEndOfFile, (*image)->filename);

        }

    }

  else

    {

      /* Failed to allocate memory */

      ThrowException(exception,ResourceLimitError,MemoryAllocationFailed,

                     (*image)->filename);

    }

  return(*image);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d B M P I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  Method ReadBMPImage reads a Microsoft Windows bitmap image file, Version

%  2, 3 (for Windows or NT), or 4, and  returns it.  It allocates the memory

%  necessary for the new Image structure and returns a pointer to the new

%  image.

%

%  The format of the ReadBMPImage method is:

%

%      image=ReadBMPImage(image_info)

%

%  A description of each parameter follows:

%

%    o image:  Method ReadBMPImage returns a pointer to the image after

%      reading.  A null image is returned if there is a memory shortage or

%      if the image cannot be read.

%

%    o image_info: Specifies a pointer to a ImageInfo structure.

%

%    o exception: return any errors or warnings in this structure.

%

%

*/

#define ThrowBMPReaderException(code_,reason_,image_) \

do { \

  MagickFreeResourceLimitedMemory(bmp_colormap); \

  MagickFreeResourceLimitedMemory(pixels); \

  ThrowReaderException(code_,reason_,image_); \

} while (0);

static Image *ReadBMPImage(const ImageInfo *image_info,ExceptionInfo *exception)

{

  BMPInfo

    bmp_info;

  Image

    *image;

  int

    logging;

  long

    y;

  magick_uint32_t

    blue,

    green,

    opacity,

    red;

  ExtendedSignedIntegralType

    start_position;

  register long

    x;

  register PixelPacket

    *q;

  register long

    i;

  register unsigned char

    *p;

  size_t

    bytes_per_line,

    count,

    length,

    pixels_size;

  unsigned char

    *bmp_colormap,

    magick[12],

    *pixels;

  unsigned int

    status;

  magick_off_t

    file_remaining,

    file_size,

    offset;

  /*

    Open image file.

  */

  assert(image_info != (const ImageInfo *) NULL);

  assert(image_info->signature == MagickSignature);

  assert(exception != (ExceptionInfo *) NULL);

  assert(exception->signature == MagickSignature);

  bmp_colormap=(unsigned char *) NULL;

  pixels=(unsigned char *) NULL;

  logging=LogMagickEvent(CoderEvent,GetMagickModule(),"enter");

  image=AllocateImage(image_info);

  image->rows=0;

  image->columns=0;

  status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);

  if (status == MagickFalse)

    ThrowBMPReaderException(FileOpenError,UnableToOpenFile,image);

  file_size=GetBlobSize(image);

  /*

    Determine if this is a BMP file.

  */

  (void) memset(&bmp_info,0,sizeof(BMPInfo));

  bmp_info.ba_offset=0;

  start_position=0;

  magick[0]=magick[1]=0;

  count=ReadBlob(image,2,(char *) magick);

  do

    {

      PixelPacket

        quantum_bits,

        shift;

      magick_uint32_t

        profile_data,

        profile_size;

      /*

        Verify BMP identifier.

      */

      /* if (bmp_info.ba_offset == 0) */ /* FIXME: Investigate. Start position needs to always advance! */

      start_position=TellBlob(image)-2;

      bmp_info.ba_offset=0;

      /* "BA" is OS/2 bitmap array file */

      while (LocaleNCompare((char *) magick,"BA",2) == 0)

        {

          bmp_info.file_size=ReadBlobLSBLong(image);

          bmp_info.ba_offset=ReadBlobLSBLong(image);

          bmp_info.offset_bits=ReadBlobLSBLong(image);

          if ((count=ReadBlob(image,2,(char *) magick)) != 2)

            break;

        }

      if (count != 2)           /* Found "BA" header from above above */

        ThrowBMPReaderException(CorruptImageError,ImproperImageHeader,image);

      if (logging )

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),"  Magick: %c%c",

                              magick[0],magick[1]);

      bmp_info.file_size=ReadBlobLSBLong(image); /* File size in bytes */

      if (logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "  File size: Claimed=%" MAGICK_SIZE_T_F "u, Actual=%"

                              MAGICK_OFF_F "d",

                              (MAGICK_SIZE_T) bmp_info.file_size, file_size);

      (void) ReadBlobLSBLong(image); /* Reserved */

      bmp_info.offset_bits=ReadBlobLSBLong(image); /* Bit map offset from start of file */

      bmp_info.size=ReadBlobLSBLong(image);  /* BMP Header size */

      if (logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "  Header size: %u\n"

                              "    Offset bits: %u\n"

                              "    Image data offset: %u",

                              bmp_info.size,

                              bmp_info.offset_bits,

                              bmp_info.ba_offset);

      if (LocaleNCompare((char *) magick,"BM",2) != 0)  /* "BM" is Windows or OS/2 file. */

        {

          if ((LocaleNCompare((char *) magick,"CI",2) != 0) ||  /* "CI" is OS/2 Color Icon */

              (bmp_info.size!=12 && bmp_info.size!=40 && bmp_info.size!=64)) /* CI chunk must have biSize only 12 or 40 or 64 */

            ThrowBMPReaderException(CorruptImageError,ImproperImageHeader,image);

        }

      if ((bmp_info.file_size != 0) && ((magick_off_t) bmp_info.file_size > file_size))

        ThrowBMPReaderException(CorruptImageError,ImproperImageHeader,image);

      if (bmp_info.offset_bits < bmp_info.size)

        ThrowBMPReaderException(CorruptImageError,ImproperImageHeader,image);

      if(bmp_info.size == 12)

        {

          /*

            Windows 2.X or OS/2 BMP image file.

          */

          bmp_info.width=(magick_int16_t) ReadBlobLSBShort(image); /* Width */

          bmp_info.height=(magick_int16_t) ReadBlobLSBShort(image); /* Height */

          bmp_info.planes=ReadBlobLSBShort(image); /* # of color planes */

          bmp_info.bits_per_pixel=ReadBlobLSBShort(image); /* Bits per pixel */

          bmp_info.x_pixels=0;

          bmp_info.y_pixels=0;

          bmp_info.number_colors=0;

          bmp_info.compression=BI_RGB;

          bmp_info.image_size=0;

          bmp_info.alpha_mask=0;

          if (logging)

            {

              (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                    "  Format: Windows 2.X or OS/2 Bitmap");

              (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                    "  Geometry: %dx%d",bmp_info.width,bmp_info.height);

              (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                    "  Planes: %u",bmp_info.planes);

              (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                    "  Bits per pixel: %u",bmp_info.bits_per_pixel);

            }

        }

      else

        {

          /*

            Microsoft Windows 3.X or later BMP image file.

          */

          switch(bmp_info.size)

            {

            case 40: if(logging)

                         (void) LogMagickEvent(CoderEvent, GetMagickModule(), "Format: MS Windows bitmap 3.X");

                     break;

            case 52: if(logging)

                         (void) LogMagickEvent(CoderEvent, GetMagickModule(), "Format: MS Windows bitmap 3.X V2");

                     break;

            case 56:if(logging)

                         (void) LogMagickEvent(CoderEvent, GetMagickModule(), "Format: MS Windows bitmap 3.X V3");

                     break;

            case 64: if(logging)

                         (void) LogMagickEvent(CoderEvent, GetMagickModule(), "Format: OS22XBITMAPHEADER");

                     break;

            case 78:

            case 108: if (logging)

                         (void) LogMagickEvent(CoderEvent, GetMagickModule(), "Format: MS Windows bitmap 3.X V4");

                     break;

            case 124: if(logging)

                         (void) LogMagickEvent(CoderEvent, GetMagickModule(), "Format: MS Windows bitmap 3.X V5");

                     break;

            default: if (bmp_info.size < 64)

                ThrowBMPReaderException(CorruptImageError, NonOS2HeaderSizeError, image);

              /* A value larger than 64 indicates a later version of the OS/2 BMP format.

                 .... as far as OS/2 development caesed we could consider to

                 close this Trojan's horse window in future. */

                     if(logging)

                         (void) LogMagickEvent(CoderEvent, GetMagickModule(), "Format: MS Windows bitmap 3.X ?");

              break;

            }

          /*

            BMP v3 defines width and height as signed LONG (32 bit) values.  If

            height is a positive number, then the image is a "bottom-up"

            bitmap with origin in the lower-left corner.  If height is a

            negative number, then the image is a "top-down" bitmap with the

            origin in the upper-left corner.  The meaning of negative values

            is not defined for width.

          */

          bmp_info.width=(magick_int32_t) ReadBlobLSBLong(image); /* Width */

          bmp_info.height=(magick_int32_t) ReadBlobLSBLong(image); /* Height */

          bmp_info.planes=ReadBlobLSBShort(image); /* # of color planes */

          bmp_info.bits_per_pixel=ReadBlobLSBShort(image); /* Bits per pixel (1/4/8/16/24/32) */

          bmp_info.compression=ReadBlobLSBLong(image); /* Compression method */

          bmp_info.image_size=ReadBlobLSBLong(image); /* Bitmap size (bytes) */

          bmp_info.x_pixels=ReadBlobLSBLong(image); /* Horizontal resolution (pixels/meter) */

          bmp_info.y_pixels=ReadBlobLSBLong(image); /* Vertical resolution (pixels/meter) */

          bmp_info.number_colors=ReadBlobLSBLong(image); /* Number of colors */

          bmp_info.colors_important=ReadBlobLSBLong(image); /* Minimum important colors */

          profile_data=0;

          profile_size=0;

          if (logging)

            {

              (void) LogMagickEvent(CoderEvent, GetMagickModule(),

                                    "    Geometry: %dx%d\n"

                                    "    Planes: %u\n"

                                    "    Bits per pixel: %u",

                                      bmp_info.width, bmp_info.height,

                                      bmp_info.planes,

                                      bmp_info.bits_per_pixel);

              if(bmp_info.compression <= BI_ALPHABITFIELDS)

                  (void) LogMagickEvent(CoderEvent, GetMagickModule(),

                                          "  Compression: %s", DecodeBiCompression(bmp_info.compression,bmp_info.size));

              else

                  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                          "  Compression: UNKNOWN (%u)",bmp_info.compression);

              (void) LogMagickEvent(CoderEvent, GetMagickModule(),

                                    "  Number of colors: %u\n"

                                    "    Important colors: %u",

                                    bmp_info.number_colors, bmp_info.colors_important);

            }

          if(bmp_info.size==64)

            {                           /* OS22XBITMAPHEADER */

              magick_uint16_t  Units;            /* Type of units used to measure resolution */

              magick_uint16_t  Reserved;         /* Pad structure to 4-byte boundary */

              magick_uint16_t  Recording;        /* Recording algorithm */

              magick_uint16_t  Rendering;        /* Halftoning algorithm used */

              magick_uint32_t  Size1;            /* Reserved for halftoning algorithm use */

              magick_uint32_t  Size2;            /* Reserved for halftoning algorithm use */

              magick_uint32_t  ColorEncoding;    /* Color model used in bitmap */

              magick_uint32_t  Identifier;       /* Reserved for application use */

              Units = ReadBlobLSBShort(image);

              Reserved = ReadBlobLSBShort(image);

              Recording = ReadBlobLSBShort(image);

              Rendering = ReadBlobLSBShort(image);

              Size1 = ReadBlobLSBLong(image);

              Size2 = ReadBlobLSBLong(image);

              ColorEncoding = ReadBlobLSBLong(image);

              Identifier = ReadBlobLSBLong(image);

              if(logging)

                  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "    Units: %u\n"

                              "    Reserved: %u\n"

                              "    Recording: %u\n"

                              "    Rendering: %u\n"

                              "    Size1: %u\n"

                              "    Size2: %u\n"

                              "    ColorEncoding: %u\n"

                              "    Identifier: %u",

                              Units, Reserved, Recording, Rendering,

                              Size1, Size2, ColorEncoding, Identifier);

                  /* OS/2 does not recognise JPEG nor PNG. */

              if(bmp_info.compression==BI_JPEG || bmp_info.compression==BI_PNG)

                  ThrowBMPReaderException(CoderError,CompressionNotValid,image)

            }

          if (bmp_info.size>=52 && bmp_info.size!=64)

            {

              bmp_info.red_mask=ReadBlobLSBLong(image);

              bmp_info.green_mask=ReadBlobLSBLong(image);

              bmp_info.blue_mask=ReadBlobLSBLong(image);

              if (bmp_info.size >= 56)

                {

                  /*

                    Read color management information.

                  */

                  bmp_info.alpha_mask=ReadBlobLSBLong(image);

                  if (image->logging)

                    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                          "Alpha Mask: 0x%04x",

                                          bmp_info.alpha_mask);

                  if (bmp_info.size > 120)

                    {

                      /*

                        https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapv4header

                      */

                      magick_uint32_t

                        v4_red_primary_x, v4_red_primary_y, v4_red_primary_z,

                        v4_green_primary_x, v4_green_primary_y, v4_green_primary_z,

                        v4_blue_primary_x, v4_blue_primary_y, v4_blue_primary_z,

                        v4_gamma_x, v4_gamma_y, v4_gamma_z;

                      double

                        bmp_gamma,

                        sum;

                      bmp_info.colorspace=(magick_int32_t) ReadBlobLSBLong(image);

                      if (image->logging)

                        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                              "BMP Colorspace: 0x%04x",

                                              bmp_info.colorspace);

                      v4_red_primary_x=ReadBlobLSBLong(image);

                      v4_red_primary_y=ReadBlobLSBLong(image);

                      v4_red_primary_z=ReadBlobLSBLong(image);

                      v4_green_primary_x=ReadBlobLSBLong(image);

                      v4_green_primary_y=ReadBlobLSBLong(image);

                      v4_green_primary_z=ReadBlobLSBLong(image);

                      v4_blue_primary_x=ReadBlobLSBLong(image);

                      v4_blue_primary_y=ReadBlobLSBLong(image);

                      v4_blue_primary_z=ReadBlobLSBLong(image);

                      v4_gamma_x = ReadBlobLSBLong(image);

                      v4_gamma_y = ReadBlobLSBLong(image);

                      v4_gamma_z = ReadBlobLSBLong(image);

                      if (LCS_CALIBRATED_RGB == bmp_info.colorspace)

                        {

                          /*

                            Decode 2^30 fixed point formatted CIE primaries.

                            https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-ciexyztriple

                            https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-ciexyz

                          */

                          bmp_info.red_primary.x=(double) v4_red_primary_x/0x3ffffff;

                          bmp_info.red_primary.y=(double) v4_red_primary_y/0x3ffffff;

                          bmp_info.red_primary.z=(double) v4_red_primary_z/0x3ffffff;

                          bmp_info.green_primary.x=(double) v4_green_primary_x/0x3ffffff;

                          bmp_info.green_primary.y=(double) v4_green_primary_y/0x3ffffff;

                          bmp_info.green_primary.z=(double) v4_green_primary_z/0x3ffffff;

                          bmp_info.blue_primary.x=(double) v4_blue_primary_x/0x3ffffff;

                          bmp_info.blue_primary.y=(double) v4_blue_primary_y/0x3ffffff;

                          bmp_info.blue_primary.z=(double) v4_blue_primary_z/0x3ffffff;

                          if (image->logging)

                            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                                  "BMP Primaries: red(%g,%g,%g),"

                                                  " green(%g,%g,%g),"

                                                  " blue(%g,%g,%g)",

                                                  bmp_info.red_primary.x,

                                                  bmp_info.red_primary.y,

                                                  bmp_info.red_primary.z,

                                                  bmp_info.green_primary.x,

                                                  bmp_info.green_primary.y,

                                                  bmp_info.green_primary.z,

                                                  bmp_info.blue_primary.x,

                                                  bmp_info.blue_primary.y,

                                                  bmp_info.blue_primary.z);

                          sum=bmp_info.red_primary.x+bmp_info.red_primary.y+bmp_info.red_primary.z;