/*

  Copyright (C) 2003 - 2023 GraphicsMagick Group

  Copyright (C) 2002 ImageMagick Studio

  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.

  Methods to import image pixels from common representations

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/bit_stream.h"

#include "magick/colormap.h"

#include "magick/constitute.h"

#include "magick/floats.h"

#include "magick/magick.h"

#include "magick/pixel_cache.h"

#include "magick/utility.h"

/*

  Type definitions

*/

static const PixelPacket BlackPixel = {0, 0, 0, OpaqueOpacity};

static const PixelPacket WhitePixel = {MaxRGB, MaxRGB, MaxRGB, OpaqueOpacity};

/*

  Macros

*/

#if defined(WORDS_BIGENDIAN)

#  define MyEndianType MSBEndian

#else

#  define MyEndianType LSBEndian

#endif

#define ImportModulo8Quantum(quantum,quantum_size,p)            \

  {                                                             \

    register unsigned int                                       \

      shift;                                                    \

                                                                \

    quantum=0;                                                  \

    if (LSBEndian != endian)                                    \

      {                                                         \

        shift=quantum_size;                                     \

        do                                                      \

          {                                                     \

            shift -= 8U;                                        \

            quantum |= (((magick_uint32_t) *p++) << shift);     \

          } while( shift > 0U);                                 \

      }                                                         \

    else                                                        \

      {                                                         \

        shift=0U;                                               \

        while ( shift < quantum_size )                          \

          {                                                     \

            quantum |= (((magick_uint32_t) *p++) << shift);     \

            shift += 8U;                                        \

          }                                                     \

      }                                                         \

  }

#define ImportUInt8Quantum(quantum,p)                           \

  {                                                             \

    quantum=(magick_uint32_t) *p++;                             \

  }

#define ImportUInt16Quantum(endian,quantum,p)                   \

  {                                                             \

    if (LSBEndian != endian)                                    \

      {                                                         \

        quantum=(((magick_uint32_t) *p++) << 8);                \

        quantum|=((magick_uint32_t) *p++);                      \

      }                                                         \

    else                                                        \

      {                                                         \

        quantum=((magick_uint32_t) *p++);                       \

        quantum|=(((magick_uint32_t) *p++) << 8);               \

      }                                                         \

  }

/*

  This algorithm has been compared with several others and did best

  overall on SPARC, PowerPC, and Intel Xeon.

*/

#define ImportUInt32Quantum(endian,quantum,p)                   \

  {                                                             \

    if (LSBEndian != endian)                                    \

      {                                                         \

        quantum=(((magick_uint32_t) *p++) << 24);               \

        quantum|=(((magick_uint32_t) *p++) << 16);              \

        quantum|=(((magick_uint32_t) *p++) << 8);               \

        quantum|=((magick_uint32_t) *p++);                      \

      }                                                         \

    else                                                        \

      {                                                         \

        quantum=((magick_uint32_t) *p++);                       \

        quantum|=(((magick_uint32_t) *p++) << 8);               \

        quantum|=(((magick_uint32_t) *p++) << 16);              \

        quantum|=(((magick_uint32_t) *p++) << 24);              \

      }                                                         \

  }

/*

  Import a 64-bit unsigned value into a 32-bit quantum type.  This

  approach is used since 64-bits is not supported internally and some

  CPUs may perform poorly when using a true 64-bit type.  In this case

  the least significant 32 bits are entirely ignored.

*/

#define ImportUInt64Quantum(endian,quantum,p)                   \

  {                                                             \

    if (LSBEndian != endian)                                    \

      {                                                         \

        quantum=(((magick_uint32_t) *p++) << 24);               \

        quantum|=(((magick_uint32_t) *p++) << 16);              \

        quantum|=(((magick_uint32_t) *p++) << 8);               \

        quantum|=((magick_uint32_t) *p++);                      \

        p+=4;                                                   \

      }                                                         \

    else                                                        \

      {                                                         \

        p+=4;                                                   \

        quantum=((magick_uint32_t) *p++);                       \

        quantum|=(((magick_uint32_t) *p++) << 8);               \

        quantum|=(((magick_uint32_t) *p++) << 16);              \

        quantum|=(((magick_uint32_t) *p++) << 24);              \

      }                                                         \

  }

#define ImportFloat16Quantum(endian,value,p)                    \

  {                                                             \

    float float_value;                                          \

    unsigned char c[2];                                         \

    if (MyEndianType == endian)                                 \

      {                                                         \

        c[0]=*p++;                                              \

        c[1]=*p++;                                              \

      }                                                         \

    else                                                        \

      {                                                         \

        c[1]=*p++;                                              \

        c[0]=*p++;                                              \

      }                                                         \

    (void) _Gm_convert_fp16_to_fp32((const fp_16bits *)c,       \

                                    &float_value);              \

    value=float_value;                                          \

  }

#define ImportFloat24Quantum(endian,value,p)                    \

  {                                                             \

    float float_value;                                          \

    unsigned char c[3];                                         \

    if (MyEndianType == endian)                                 \

      {                                                         \

        c[0]=*p++;                                              \

        c[1]=*p++;                                              \

        c[2]=*p++;                                              \

      }                                                         \

    else                                                        \

      {                                                         \

        c[2]=*p++;                                              \

        c[1]=*p++;                                              \

        c[0]=*p++;                                              \

      }                                                         \

    (void) _Gm_convert_fp24_to_fp32((const fp_24bits *)c,       \

                                    &float_value,               \

                                    RANGE_LIMITED);             \

    value=float_value;                                          \

}

#define ImportFloat32Quantum(endian,value,p)    \

  {                                             \

    if (MyEndianType == endian)                 \

      {                                         \

        value=*((float *) p);                   \

        p += sizeof(float);                     \

      }                                         \

    else                                        \

      {                                         \

        union                                   \

        {                                       \

          float f;                              \

          unsigned char c[4];                   \

        } fu_;                                  \

                                                \

        fu_.c[3]=*p++;                          \

        fu_.c[2]=*p++;                          \

        fu_.c[1]=*p++;                          \

        fu_.c[0]=*p++;                          \

        value=fu_.f;                            \

      }                                         \

  }

#define ImportFloat64Quantum(endian,value,p)    \

  {                                             \

    if (MyEndianType == endian)                 \

      {                                         \

        value=*((double *) p);                  \

        p += sizeof(double);                    \

      }                                         \

    else                                        \

      {                                         \

        union                                   \

        {                                       \

          double d;                             \

          unsigned char c[8];                   \

        } du_;                                  \

                                                \

        du_.c[7]=*p++;                          \

        du_.c[6]=*p++;                          \

        du_.c[5]=*p++;                          \

        du_.c[4]=*p++;                          \

        du_.c[3]=*p++;                          \

        du_.c[2]=*p++;                          \

        du_.c[1]=*p++;                          \

        du_.c[0]=*p++;                          \

        value=du_.d;                            \

      }                                         \

  }

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   I m p o r t I m a g e P i x e l A r e a                                   %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  ImportImagePixelArea() transfers one or more pixel components from a user

%  supplied buffer into the default image pixel cache view. By default,

%  values are read in network (big-endian) byte/bit order.  By setting the

%  'endian' member of ExportPixelAreaOptions, 16, 32 and 64-bit values may

%  be output as little (LSBEndian), big (MSBEndian), or host native

%  (NativeEndian) endian values.  This function is quite powerful in that

%  besides common native CPU type sizes, it can support any integer bit

%  depth from 1 to 32 (e.g. 13), 64-bits, as well as 32 and 64-bit float.

%

%  MagickPass is returned if the pixels are successfully transferred,

%  otherwise MagickFail.

%

%  The format of the ImportImagePixelArea method is:

%

%      MagickPassFail ImportImagePixelArea(Image *image,

%                                          const QuantumType quantum_type,

%                                          const unsigned int quantum_size,

%                                          const unsigned char *source,

%                                          const ImportPixelAreaOptions *options,

%                                          ImportPixelAreaInfo *import_info)

%

%  A description of each parameter follows:

%

%    o status: Method PushImagePixels returns MagickPass if the pixels are

%      successfully transferred, otherwise MagickFail.

%

%    o image: The image.

%

%    o quantum_type: Declare which pixel components to transfer (AlphaQuantum,

%        BlackQuantum, BlueQuantum, CMYKAQuantum, CMYKQuantum, CyanQuantum,

%        GrayAlphaQuantum, GrayQuantum, GreenQuantum, IndexAlphaQuantum,

%        IndexQuantum, MagentaQuantum, RGBAQuantum, RGBQuantum,

%        RedQuantum, YellowQuantum)

%

%    o quantum_size: Bits per quantum sample (range 1-32, and 64).

%

%    o source:  The pixel components are transferred from this buffer.

%

%    o options: Additional options specific to quantum_type (may be NULL).

%

%    o import_info : Populated with information regarding the pixels

%               imported (may be NULL)

%

*/

MagickExport MagickPassFail ImportImagePixelArea(Image *image,

  const QuantumType quantum_type,const unsigned int quantum_size,

  const unsigned char *source,const ImportPixelAreaOptions *options,

  ImportPixelAreaInfo *import_info)

{

  return ImportViewPixelArea(AccessDefaultCacheView(image),

                             quantum_type,quantum_size,

                             source,options,import_info);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   I m p o r t V i e w P i x e l A r e a                                     %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  ImportViewPixelArea() transfers one or more pixel components from a user

%  supplied buffer into the specified image pixel cache view of an image. By

%  default, values are read in network (big-endian) byte/bit order.  By

%  setting the 'endian' member of ExportPixelAreaOptions, 16, 32 and 64-bit

%  values may be output as little (LSBEndian), big (MSBEndian), or host

%  native (NativeEndian) endian values.  This function is quite powerful in

%  that besides common native CPU type sizes, it can support any integer bit

%  depth from 1 to 32 (e.g. 13), 64-bits, as well as 32 and 64-bit float.

%

%  MagickPass is returned if the pixels are successfully transferred,

%  otherwise MagickFail.

%

%  The format of the ImportViewPixelArea method is:

%

%      MagickPassFail ImportViewPixelArea(ViewInfo *view,

%                                         const QuantumType quantum_type,

%                                         const unsigned int quantum_size,

%                                         const unsigned char *source,

%                                         const ImportPixelAreaOptions *options,

%                                         ImportPixelAreaInfo *import_info)

%

%  A description of each parameter follows:

%

%    o status: Method PushImagePixels returns MagickPass if the pixels are

%      successfully transferred, otherwise MagickFail.

%

%    o view: The pixel view to import pixels into.

%

%    o quantum_type: Declare which pixel components to transfer (AlphaQuantum,

%        BlackQuantum, BlueQuantum, CMYKAQuantum, CMYKQuantum, CyanQuantum,

%        GrayAlphaQuantum, GrayQuantum, GreenQuantum, IndexAlphaQuantum,

%        IndexQuantum, MagentaQuantum, RGBAQuantum, RGBQuantum,

%        RedQuantum, YellowQuantum)

%

%    o quantum_size: Bits per quantum sample (range 1-32, and 64).

%

%    o source:  The pixel components are transferred from this buffer.

%

%    o options: Additional options specific to quantum_type (may be NULL).

%

%    o import_info : Populated with information regarding the pixels

%               imported (may be NULL)

%

*/

static MagickPassFail

ImportIndexQuantumType(const unsigned char *source,

                       PixelPacket* restrict q,

                       IndexPacket * restrict indexes,

                       const unsigned long number_pixels,

                       const unsigned int quantum_size,

                       const QuantumSampleType sample_type,

                       const unsigned int unsigned_maxvalue,

                       const EndianType endian,

                       Image *image,

                       ImportPixelAreaInfo *import_info)

{

  const unsigned char * restrict

    p;

  register unsigned long

    x;

  register magick_uint32_t

    index;

  assert(image->colors <= MaxColormapSize);

  if ((image->storage_class != PseudoClass) ||

      (image->colors == 0) ||

      (indexes == (IndexPacket *) NULL))

    ThrowBinaryException3(ImageError,ImageIsNotColormapped,

                          UnableToImportImagePixels);

  p=source;

  if (sample_type == UnsignedQuantumSampleType)

    {

      switch (quantum_size)

        {

        case 1:

          {

            /*

              Special fast support for two colors.

            */

            register unsigned int

              bit = 8U;

            for (x = number_pixels ; x != 0 ; --x )

              {

                --bit;

                index=(*p >> bit) & 0x01;

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q++=image->colormap[index];

                if (bit == 0)

                  {

                    bit=8;

                    p++;

                  }

              }

            break;

          }

        case 4:

          {

            /*

              Special fast support for 16 colors.

            */

            register unsigned int

              state = 0;

            for (x = number_pixels ; x != 0 ; --x )

              {

                state ^= 1; /* Produces 1 0 1 0 ... */

                index=(IndexPacket) ((state ? (*p >> 4) : (*p++)) & 0xf);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q++=image->colormap[index];

              }

            break;

          }

        case 8:

          {

            if (unsigned_maxvalue <= (unsigned int) (image->colors-1))

              {

                /*

                  Special case for when it is impossible to

                  overflow the colormap range.

                */

                for (x = number_pixels; x != 0; --x)

                  {

                    ImportUInt8Quantum(index,p);

                    *indexes++=index;

                    *q++=image->colormap[index];

                  }

              }

            else

              {

                for (x = number_pixels; x != 0; --x)

                  {

                    ImportUInt8Quantum(index,p);

                    VerifyColormapIndex(image,index);

                    *indexes++=index;

                    *q++=image->colormap[index];

                  }

              }

            break;

          }

        case 16:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportUInt16Quantum(endian,index,p);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q++=image->colormap[index];

              }

            break;

          }

        case 32:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportUInt32Quantum(endian,index,p);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q++=image->colormap[index];

              }

            break;

          }

        case 64:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportUInt64Quantum(endian,index,p);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q++=image->colormap[index];

              }

            break;

          }

        default:

          {

            /*

              Arbitrary sample size

            */

            BitStreamReadHandle

              stream;

            MagickBitStreamInitializeRead(&stream,p);

            for (x = number_pixels; x != 0; --x)

              {

                index=MagickBitStreamMSBRead(&stream,quantum_size);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q++=image->colormap[index];

              }

            break;

          }

        }

    }

  if (import_info)

    {

      import_info->bytes_imported=p-source;

    }

  return MagickPass;

}

static MagickPassFail

ImportIndexAlphaQuantumType(const unsigned char *source,

                            PixelPacket* restrict q,

                            IndexPacket * restrict indexes,

                            const unsigned long number_pixels,

                            const unsigned int quantum_size,

                            const QuantumSampleType sample_type,

                            const unsigned int unsigned_scale,

                            const EndianType endian,

                            Image *image,

                            ImportPixelAreaInfo *import_info)

{

  const unsigned char * restrict

    p;

  register unsigned long

    x;

  register magick_uint32_t

    index,

    unsigned_value;

   unsigned int

     sample_bits;

  assert(image->colors <= MaxColormapSize);

  if ((image->storage_class != PseudoClass) ||

      (image->colors == 0) ||

      (indexes == (IndexPacket *) NULL))

    ThrowBinaryException3(ImageError,ImageIsNotColormapped,

                          UnableToImportImagePixels);

  sample_bits=quantum_size;

  p=source;

  if (sample_type == UnsignedQuantumSampleType)

    {

      switch(quantum_size)

        {

        case 8:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportUInt8Quantum(index,p);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q=image->colormap[index];

                ImportUInt8Quantum(unsigned_value,p);

                SetOpacitySample(q,MaxRGB-ScaleCharToQuantum(unsigned_value));

                q++;

              }

            break;

          }

        case 16:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportUInt16Quantum(endian,index,p);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q=image->colormap[index];

                ImportUInt16Quantum(endian,unsigned_value,p);

                SetOpacitySample(q,MaxRGB-ScaleShortToQuantum(unsigned_value));

                q++;

              }

            break;

          }

        case 32:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportUInt32Quantum(endian,index,p);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q=image->colormap[index];

                ImportUInt32Quantum(endian,unsigned_value,p);

                SetOpacitySample(q,MaxRGB-ScaleLongToQuantum(unsigned_value));

                q++;

              }

            break;

          }

        case 64:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportUInt64Quantum(endian,index,p);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q=image->colormap[index];

                ImportUInt64Quantum(endian,unsigned_value,p);

                SetOpacitySample(q,MaxRGB-ScaleLongToQuantum(unsigned_value));

                q++;

              }

            break;

          }

        default:

          {

            /*

              Arbitrary sample size

            */

            BitStreamReadHandle

              stream;

            MagickBitStreamInitializeRead(&stream,p);

            for (x = number_pixels; x != 0; --x)

              {

                index=MagickBitStreamMSBRead(&stream,quantum_size);

                VerifyColormapIndex(image,index);

                *indexes++=index;

                *q=image->colormap[index];

                unsigned_value=MagickBitStreamMSBRead(&stream,quantum_size);

                if (QuantumDepth >  sample_bits)

                  unsigned_value *= unsigned_scale;

                else if (QuantumDepth <  sample_bits)

                  unsigned_value /= unsigned_scale;

                SetOpacitySample(q,MaxRGB-unsigned_value);

                q++;

              }

            break;

          }

        }

    }

  if (import_info)

    {

      import_info->bytes_imported=p-source;

    }

  return MagickPass;

}

static MagickPassFail

ImportGrayQuantumType(const unsigned char *source,

                      PixelPacket* restrict q,

                      IndexPacket * restrict indexes,

                      const unsigned long number_pixels,

                      const unsigned int quantum_size,

                      const QuantumSampleType sample_type,

                      const unsigned int unsigned_scale,

                      const unsigned int unsigned_maxvalue,

                      const MagickBool grayscale_miniswhite,

                      const double double_minvalue,

                      const double double_scale,

                      const EndianType endian,

                      Image *image,

                      ImportPixelAreaInfo *import_info)

{

  const unsigned char * restrict

    p;

  register unsigned long

    x;

  double

    double_value;

  register magick_uint32_t

    index,

    unsigned_value;

  unsigned int

    sample_bits;

  sample_bits=quantum_size;

  p=source;

  if (sample_type == UnsignedQuantumSampleType)

    {

      if (DirectClass == image->storage_class)

        {

          /*

            DirectClass representation.

          */

          switch (quantum_size)

            {

            case 1:

              {

                /*

                  Special fast support for bi-level gray.

                */

                register int

                  bit = 8;

                PixelPacket

                  min_val,

                  max_val;

                if (grayscale_miniswhite)

                  {

                    min_val=WhitePixel;

                    max_val=BlackPixel;

                  }

                else

                  {

                    min_val=BlackPixel;

                    max_val=WhitePixel;

                  }

                for (x = number_pixels ; x != 0 ; --x )

                  {

                    --bit;

                    *q++=(((*p >> bit) & 0x01) ? max_val : min_val);

                    if (bit == 0)

                      {

                        bit=8;

                        p++;

                      }

                  }

                if (bit != 8)

                  p++;

                break;

              }

            case 8:

              {

                if (grayscale_miniswhite)

                  {

                    for (x = number_pixels; x != 0; --x)

                      {

                        SetGraySample(q,MaxRGB-ScaleCharToQuantum(*p++));

                        SetOpacitySample(q,OpaqueOpacity);

                        q++;

                      }

                  }

                else

                  {

                    for (x = number_pixels; x != 0; --x)

                      {

                        SetGraySample(q,ScaleCharToQuantum(*p++));

                        SetOpacitySample(q,OpaqueOpacity);

                        q++;

                      }

                  }

                break;

              }

            case 16:

              {

                if (grayscale_miniswhite)

                  {

                    for (x = number_pixels; x != 0; --x)

                      {

                        ImportUInt16Quantum(endian,unsigned_value,p);

                        SetGraySample(q,MaxRGB-ScaleShortToQuantum(unsigned_value));

                        SetOpacitySample(q,OpaqueOpacity);

                        q++;

                      }

                  }

                else

                  {

                    for (x = number_pixels; x != 0; --x)

                      {

                        ImportUInt16Quantum(endian,unsigned_value,p);

                        SetGraySample(q,ScaleShortToQuantum(unsigned_value));

                        SetOpacitySample(q,OpaqueOpacity);

                        q++;

                      }

                  }

                break;

              }

            case 32:

              {

                if (grayscale_miniswhite)

                  {

                    for (x = number_pixels; x != 0; --x)

                      {

                        ImportUInt32Quantum(endian,unsigned_value,p);

                        SetGraySample(q,MaxRGB-ScaleLongToQuantum(unsigned_value));

                        SetOpacitySample(q,OpaqueOpacity);

                        q++;

                      }

                  }

                else

                  {

                    for (x = number_pixels; x != 0; --x)

                      {

                        ImportUInt32Quantum(endian,unsigned_value,p);

                        SetGraySample(q,ScaleLongToQuantum(unsigned_value));

                        SetOpacitySample(q,OpaqueOpacity);

                        q++;

                      }

                  }

                break;

              }

            case 64:

              {

                if (grayscale_miniswhite)

                  {

                    for (x = number_pixels; x != 0; --x)

                      {

                        ImportUInt64Quantum(endian,unsigned_value,p);

                        SetGraySample(q,MaxRGB-ScaleLongToQuantum(unsigned_value));

                        SetOpacitySample(q,OpaqueOpacity);

                        q++;

                      }

                  }

                else

                  {

                    for (x = number_pixels; x != 0; --x)

                      {

                        ImportUInt64Quantum(endian,unsigned_value,p);

                        SetGraySample(q,ScaleLongToQuantum(unsigned_value));

                        SetOpacitySample(q,OpaqueOpacity);

                        q++;

                      }

                  }

                break;

              }

            default:

              {

                BitStreamReadHandle

                  stream;

                MagickBitStreamInitializeRead(&stream,p);

                for (x = number_pixels; x != 0; --x)

                  {

                    unsigned_value=MagickBitStreamMSBRead(&stream,quantum_size);

                    if (QuantumDepth >  sample_bits)

                      unsigned_value *= unsigned_scale;

                    else if (QuantumDepth <  sample_bits)

                      unsigned_value /= unsigned_scale;

                    if (grayscale_miniswhite)

                      unsigned_value = MaxRGB-unsigned_value;

                    SetGraySample(q,unsigned_value);

                    SetOpacitySample(q,OpaqueOpacity);

                    q++;

                  }

                break;

              }

            }

        }

      else

        {

          /*

            PseudoClass representation.

            Note that this implementation assumes that the

            colormap is written in ascending levels of intensity

            as produced by AllocateImageColormap().  Some old

            code may assume that 'miniswhite' inverts the

            colormap order as well.

          */

          assert(image->colors <= MaxColormapSize);

          if ((image->storage_class != PseudoClass) ||

              (image->colors == 0) ||

              (indexes == (IndexPacket *) NULL))

            ThrowBinaryException3(ImageError,ImageIsNotColormapped,

                                  UnableToImportImagePixels);

          switch (quantum_size)

            {

            case 1:

              {

                /*

                  Special fast support for bi-level gray.

                */

                register int

                  bit = 8;

                for (x = number_pixels ; x != 0 ; --x )

                  {

                    --bit;

                    index=(*p >> bit) & 0x01;

                    if (grayscale_miniswhite)

                      index ^= 0x01;

                    *indexes++=index;

                    *q++=image->colormap[index];

                    if (bit == 0)

                      {

                        bit=8;

                        p++;

                      }

                  }

                if (bit != 8)

                  p++;

                break;

              }

            case 8:

              {

                for (x = number_pixels; x != 0; --x)

                  {

                    ImportUInt8Quantum(index,p);

                    VerifyColormapIndex(image,index);

                    if (grayscale_miniswhite)

                      index=(image->colors-1)-index;

                    *indexes++=index;

                    *q++=image->colormap[index];

                  }

                break;

              }

            case 16:

              {

                for (x = number_pixels; x != 0; --x)

                  {

                    ImportUInt16Quantum(endian,index,p);

                    VerifyColormapIndex(image,index);

                    if (grayscale_miniswhite)

                      index=(image->colors-1)-index;

                    *indexes++=index;

                    *q++=image->colormap[index];

                  }

                break;

              }

            case 32:

              {

                for (x = number_pixels; x != 0; --x)

                  {

                    ImportUInt32Quantum(endian,index,p);

                    VerifyColormapIndex(image,index);

                    if (grayscale_miniswhite)

                      index=(image->colors-1)-index;

                    *indexes++=index;

                    *q++=image->colormap[index];

                  }

                break;

              }

            case 64:

              {

                for (x = number_pixels; x != 0; --x)

                  {

                    ImportUInt64Quantum(endian,index,p);

                    VerifyColormapIndex(image,index);

                    if (grayscale_miniswhite)

                      index=(image->colors-1)-index;

                    *indexes++=index;

                    *q++=image->colormap[index];

                  }

                break;

              }

            default:

              {

                /*

                  Arbitrary sample size

                */

                BitStreamReadHandle

                  stream;

                register unsigned int

                  indexes_scale = 1U;

                if (unsigned_maxvalue > (image->colors-1))

                  indexes_scale=(unsigned_maxvalue/(image->colors-1));

                MagickBitStreamInitializeRead(&stream,p);

                for (x = number_pixels; x != 0; --x)

                  {

                    index=MagickBitStreamMSBRead(&stream,quantum_size);

                    index /= indexes_scale;

                    VerifyColormapIndex(image,index);

                    if (grayscale_miniswhite)

                      index=(image->colors-1)-index;

                    *indexes++=index;

                    *q++=image->colormap[index];

                  }

                break;

              }

            }

        }

    }

  else if (sample_type == FloatQuantumSampleType)

    {

      switch (quantum_size)

        {

        case 16:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportFloat16Quantum(endian,double_value,p);

                double_value -= double_minvalue;

                double_value *= double_scale;

                SetGraySample(q,RoundDoubleToQuantumN(double_value));

                q++;

              }

            break;

          }

        case 24:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportFloat24Quantum(endian,double_value,p);

                double_value -= double_minvalue;

                double_value *= double_scale;

                SetGraySample(q,RoundDoubleToQuantumN(double_value));

                q++;

              }

            break;

          }

        case 32:

          {

            for (x = number_pixels; x != 0; --x)

              {

                ImportFloat32Quantum(endian,double_value,p);

                double_value -= double_minvalue;

                double_value *= double_scale;

                SetGraySample(q,RoundDoubleToQuantumN(double_value));