/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%                QQQ   U   U   AAA   N   N  TTTTT  U   U  M   M               %

%               Q   Q  U   U  A   A  NN  N    T    U   U  MM MM               %

%               Q   Q  U   U  AAAAA  N N N    T    U   U  M M M               %

%               Q  QQ  U   U  A   A  N  NN    T    U   U  M   M               %

%                QQQQ   UUU   A   A  N   N    T     UUU   M   M               %

%                                                                             %

%                   IIIII  M   M  PPPP    OOO   RRRR   TTTTT                  %

%                     I    MM MM  P   P  O   O  R   R    T                    %

%                     I    M M M  PPPP   O   O  RRRR     T                    %

%                     I    M   M  P      O   O  R R      T                    %

%                   IIIII  M   M  P       OOO   R  R     T                    %

%                                                                             %

%                 MagickCore Methods to Import Quantum Pixels                 %

%                                                                             %

%                             Software Design                                 %

%                                  Cristy                                     %

%                               October 1998                                  %

%                                                                             %

%                                                                             %

%  Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization         %

%  dedicated to making software imaging solutions freely available.           %

%                                                                             %

%  You may not use this file except in compliance with the License.  You may  %

%  obtain a copy of the License at                                            %

%                                                                             %

%    https://imagemagick.org/script/license.php                               %

%                                                                             %

%  Unless required by applicable law or agreed to in writing, software        %

%  distributed under the License is distributed on an "AS IS" BASIS,          %

%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %

%  See the License for the specific language governing permissions and        %

%  limitations under the License.                                             %

%                                                                             %

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

%

%

*/

/*

  Include declarations.

*/

#include "MagickCore/studio.h"

#include "MagickCore/property.h"

#include "MagickCore/blob.h"

#include "MagickCore/blob-private.h"

#include "MagickCore/color-private.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/cache.h"

#include "MagickCore/constitute.h"

#include "MagickCore/delegate.h"

#include "MagickCore/geometry.h"

#include "MagickCore/list.h"

#include "MagickCore/magick.h"

#include "MagickCore/memory_.h"

#include "MagickCore/monitor.h"

#include "MagickCore/option.h"

#include "MagickCore/pixel.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/quantum.h"

#include "MagickCore/quantum-private.h"

#include "MagickCore/resource_.h"

#include "MagickCore/semaphore.h"

#include "MagickCore/statistic.h"

#include "MagickCore/stream.h"

#include "MagickCore/string_.h"

#include "MagickCore/utility.h"

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   I m p o r t Q u a n t u m P i x e l s                                     %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

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

%  supplied buffer into the image pixel cache of an image.  The pixels are

%  expected in network byte order.  It returns the number of imported pixels.

%

%  The format of the ImportQuantumPixels method is:

%

%      size_t ImportQuantumPixels(const Image *image,CacheView *image_view,

%        QuantumInfo *quantum_info,const QuantumType quantum_type,

%        const unsigned char *magick_restrict pixels,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image: the image.

%

%    o image_view: the image cache view.

%

%    o quantum_info: the quantum info.

%

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

%      blue, opacity, RGB, or RGBA).

%

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

%

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

%

*/

static inline Quantum PushColormapIndex(const Image *image,const size_t index,

  MagickBooleanType *range_exception)

{

  if (index < image->colors)

    return((Quantum) index);

  *range_exception=MagickTrue;

  return((Quantum) 0);

}

static inline const unsigned char *PushDoublePixel(QuantumInfo *quantum_info,

  const unsigned char *magick_restrict pixels,double *pixel)

{

  double

    *p;

  unsigned char

    quantum[8];

  if (quantum_info->endian == LSBEndian)

    {

      quantum[0]=(*pixels++);

      quantum[1]=(*pixels++);

      quantum[2]=(*pixels++);

      quantum[3]=(*pixels++);

      quantum[4]=(*pixels++);

      quantum[5]=(*pixels++);

      quantum[6]=(*pixels++);

      quantum[7]=(*pixels++);

    }

  else

    {

      quantum[7]=(*pixels++);

      quantum[6]=(*pixels++);

      quantum[5]=(*pixels++);

      quantum[4]=(*pixels++);

      quantum[3]=(*pixels++);

      quantum[2]=(*pixels++);

      quantum[1]=(*pixels++);

      quantum[0]=(*pixels++);

    }

  p=(double *) quantum;

  *pixel=(*p);

  *pixel-=quantum_info->minimum;

  *pixel*=quantum_info->scale;

  return(pixels);

}

static inline float ScaleFloatPixel(const QuantumInfo *quantum_info,

  const unsigned char *quantum)

{

  double

    pixel;

  pixel=(double) (*((float *) quantum));

  pixel-=quantum_info->minimum;

  pixel*=quantum_info->scale;

  if (pixel < (double) -FLT_MAX)

    return(-FLT_MAX);

  if (pixel > (double) FLT_MAX)

    return(FLT_MAX);

  return((float) pixel);

}

static inline const unsigned char *PushQuantumFloatPixel(

  const QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,

  float *pixel)

{

  unsigned char

    quantum[4];

  if (quantum_info->endian == LSBEndian)

    {

      quantum[0]=(*pixels++);

      quantum[1]=(*pixels++);

      quantum[2]=(*pixels++);

      quantum[3]=(*pixels++);

    }

  else

    {

      quantum[3]=(*pixels++);

      quantum[2]=(*pixels++);

      quantum[1]=(*pixels++);

      quantum[0]=(*pixels++);

    }

  *pixel=ScaleFloatPixel(quantum_info,quantum);

  return(pixels);

}

static inline const unsigned char *PushQuantumFloat24Pixel(

  const QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,

  float *pixel)

{

  unsigned char

    quantum[4];

  if (quantum_info->endian == LSBEndian)

    {

      quantum[0]=(*pixels++);

      quantum[1]=(*pixels++);

      quantum[2]=(*pixels++);

    }

  else

    {

      quantum[2]=(*pixels++);

      quantum[1]=(*pixels++);

      quantum[0]=(*pixels++);

    }

  if ((quantum[0] | quantum[1] | quantum[2]) == 0U)

    quantum[3]=0;

  else

    {

      unsigned char

        exponent,

        sign_bit;

      sign_bit=(quantum[2] & 0x80);

      exponent=(quantum[2] & 0x7F);

      if (exponent != 0)

        exponent=exponent-63+127;

      quantum[3]=sign_bit | (exponent >> 1);

      quantum[2]=((exponent & 1) << 7) | ((quantum[1] & 0xFE) >> 1);

      quantum[1]=((quantum[1] & 0x01) << 7) | ((quantum[0] & 0xFE) >> 1);

      quantum[0]=(quantum[0] & 0x01) << 7;

    }

  *pixel=ScaleFloatPixel(quantum_info,quantum);

  return(pixels);

}

static inline const unsigned char *PushQuantumPixel(QuantumInfo *quantum_info,

  const unsigned char *magick_restrict pixels,unsigned int *quantum)

{

  ssize_t

    i;

  size_t

    quantum_bits;

  *quantum=(QuantumAny) 0;

  for (i=(ssize_t) quantum_info->depth; i > 0L; )

  {

    if (quantum_info->state.bits == 0UL)

      {

        quantum_info->state.pixel=(*pixels++);

        quantum_info->state.bits=8UL;

      }

    quantum_bits=(size_t) i;

    if (quantum_bits > quantum_info->state.bits)

      quantum_bits=quantum_info->state.bits;

    i-=(ssize_t) quantum_bits;

    quantum_info->state.bits-=quantum_bits;

    if (quantum_bits < 64)

      *quantum=(unsigned int) (((MagickSizeType) *quantum << quantum_bits) |

        ((quantum_info->state.pixel >> quantum_info->state.bits) &~

        ((~0UL) << quantum_bits)));

  }

  return(pixels);

}

static inline const unsigned char *PushQuantumLongPixel(

  QuantumInfo *quantum_info,const unsigned char *magick_restrict pixels,

  unsigned int *quantum)

{

  ssize_t

    i;

  size_t

    quantum_bits;

  *quantum=0UL;

  for (i=(ssize_t) quantum_info->depth; i > 0; )

  {

    if (quantum_info->state.bits == 0)

      {

        pixels=PushLongPixel(quantum_info->endian,pixels,

          &quantum_info->state.pixel);

        quantum_info->state.bits=32U;

      }

    quantum_bits=(size_t) i;

    if (quantum_bits > quantum_info->state.bits)

      quantum_bits=quantum_info->state.bits;

    *quantum|=(((quantum_info->state.pixel >> (32U-quantum_info->state.bits)) &

      quantum_info->state.mask[quantum_bits]) << ((ssize_t)

      quantum_info->depth-i));

    i-=(ssize_t) quantum_bits;

    quantum_info->state.bits-=quantum_bits;

  }

  return(pixels);

}

static void ImportPixelChannel(const Image *image,QuantumInfo *quantum_info,

  const MagickSizeType number_pixels,const unsigned char *magick_restrict p,

  Quantum *magick_restrict q,PixelChannel channel)

{

  QuantumAny

    range;

  ssize_t

    x;

  q+=(ptrdiff_t) image->channel_map[channel].offset;

  switch (quantum_info->depth)

  {

    case 8:

    {

      unsigned char

        pixel;

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushCharPixel(p,&pixel);

        *q=ScaleCharToQuantum(pixel);

        p+=(ptrdiff_t) quantum_info->pad;

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

    case 16:

    {

      unsigned short

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            *q=ClampToQuantum((double) QuantumRange*(double)

              HalfToSinglePrecision(pixel));

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushShortPixel(quantum_info->endian,p,&pixel);

        *q=ScaleShortToQuantum(pixel);

        p+=(ptrdiff_t) quantum_info->pad;

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

    case 32:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          float

            pixel;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushQuantumFloatPixel(quantum_info,p,&pixel);

            *q=ClampToQuantum(pixel);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      else

        {

          unsigned int

            pixel;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushLongPixel(quantum_info->endian,p,&pixel);

            *q=ScaleLongToQuantum(pixel);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

    }

    case 24:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          float

            pixel;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);

            *q=ClampToQuantum(pixel);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      magick_fallthrough;

    }

    case 64:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          double

            pixel;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushDoublePixel(quantum_info,p,&pixel);

            *q=ClampToQuantum(pixel);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      magick_fallthrough;

    }

    default:

    {

      unsigned int

        pixel;

      range=GetQuantumRange(quantum_info->depth);

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushQuantumPixel(quantum_info,p,&pixel);

        *q=ScaleAnyToQuantum(pixel,range);

        p+=(ptrdiff_t) quantum_info->pad;

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

  }

}

static void ImportAlphaQuantum(const Image *image,QuantumInfo *quantum_info,

  const MagickSizeType number_pixels,const unsigned char *magick_restrict p,

  Quantum *magick_restrict q,ExceptionInfo *exception)

{

  if (image->alpha_trait == UndefinedPixelTrait)

    {

      (void) ThrowMagickException(exception,GetMagickModule(),ImageError,

        "ImageDoesNotHaveAnAlphaChannel","`%s'",image->filename);

      return;

    }

  ImportPixelChannel(image,quantum_info,number_pixels,p,q,AlphaPixelChannel);

}

static void ImportBGRQuantum(const Image *image,QuantumInfo *quantum_info,

  const MagickSizeType number_pixels,const unsigned char *magick_restrict p,

  Quantum *magick_restrict q)

{

  QuantumAny

    range;

  ssize_t

    x;

  ssize_t

    bit;

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

  assert(image->signature == MagickCoreSignature);

  switch (quantum_info->depth)

  {

    case 8:

    {

      unsigned char

        pixel;

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushCharPixel(p,&pixel);

        SetPixelBlue(image,ScaleCharToQuantum(pixel),q);

        p=PushCharPixel(p,&pixel);

        SetPixelGreen(image,ScaleCharToQuantum(pixel),q);

        p=PushCharPixel(p,&pixel);

        SetPixelRed(image,ScaleCharToQuantum(pixel),q);

        SetPixelAlpha(image,OpaqueAlpha,q);

        p+=(ptrdiff_t) quantum_info->pad;

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

    case 10:

    {

      unsigned int

        pixel;

      range=GetQuantumRange(quantum_info->depth);

      if (quantum_info->pack == MagickFalse)

        {

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushLongPixel(quantum_info->endian,p,&pixel);

            SetPixelRed(image,ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range),q);

            SetPixelGreen(image,ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range),

              q);

            SetPixelBlue(image,ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range),q);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      if (quantum_info->quantum == 32U)

        {

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushQuantumLongPixel(quantum_info,p,&pixel);

            SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);

            p=PushQuantumLongPixel(quantum_info,p,&pixel);

            SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);

            p=PushQuantumLongPixel(quantum_info,p,&pixel);

            SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

    case 12:

    {

      range=GetQuantumRange(quantum_info->depth);

      if (quantum_info->pack == MagickFalse)

        {

          unsigned short

            pixel;

          for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)

          {

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            switch (x % 3)

            {

              default:

              case 0:

              {

                SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                break;

              }

              case 1:

              {

                SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                break;

              }

              case 2:

              {

                SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                q+=(ptrdiff_t) GetPixelChannels(image);

                break;

              }

            }

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            switch ((x+1) % 3)

            {

              default:

              case 0:

              {

                SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                break;

              }

              case 1:

              {

                SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                break;

              }

              case 2:

              {

                SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                q+=(ptrdiff_t) GetPixelChannels(image);

                break;

              }

            }

            p+=(ptrdiff_t) quantum_info->pad;

          }

          for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)

          {

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            switch ((x+bit) % 3)

            {

              default:

              case 0:

              {

                SetPixelRed(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                break;

              }

              case 1:

              {

                SetPixelGreen(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                break;

              }

              case 2:

              {

                SetPixelBlue(image,ScaleAnyToQuantum((QuantumAny) (pixel >> 4),

                  range),q);

                q+=(ptrdiff_t) GetPixelChannels(image);

                break;

              }

            }

            p+=(ptrdiff_t) quantum_info->pad;

          }

          if (bit != 0)

            p++;

          break;

        }

      else

        {

          unsigned int

            pixel;

          if (quantum_info->quantum == 32U)

            {

              for (x=0; x < (ssize_t) number_pixels; x++)

              {

                p=PushQuantumLongPixel(quantum_info,p,&pixel);

                SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);

                p=PushQuantumLongPixel(quantum_info,p,&pixel);

                SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);

                p=PushQuantumLongPixel(quantum_info,p,&pixel);

                SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              break;

            }

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushQuantumPixel(quantum_info,p,&pixel);

            SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);

            p=PushQuantumPixel(quantum_info,p,&pixel);

            SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);

            p=PushQuantumPixel(quantum_info,p,&pixel);

            SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

    }

    case 16:

    {

      unsigned short

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)

              HalfToSinglePrecision(pixel)),q);

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)

              HalfToSinglePrecision(pixel)),q);

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)

              HalfToSinglePrecision(pixel)),q);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushShortPixel(quantum_info->endian,p,&pixel);

        SetPixelBlue(image,ScaleShortToQuantum(pixel),q);

        p=PushShortPixel(quantum_info->endian,p,&pixel);

        SetPixelGreen(image,ScaleShortToQuantum(pixel),q);

        p=PushShortPixel(quantum_info->endian,p,&pixel);

        SetPixelRed(image,ScaleShortToQuantum(pixel),q);

        p+=(ptrdiff_t) quantum_info->pad;

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

    case 32:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          float

            pixel;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushQuantumFloatPixel(quantum_info,p,&pixel);

            SetPixelRed(image,ClampToQuantum(pixel),q);

            p=PushQuantumFloatPixel(quantum_info,p,&pixel);

            SetPixelGreen(image,ClampToQuantum(pixel),q);

            p=PushQuantumFloatPixel(quantum_info,p,&pixel);

            SetPixelBlue(image,ClampToQuantum(pixel),q);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      else

        {

          unsigned int

            pixel;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushLongPixel(quantum_info->endian,p,&pixel);

            SetPixelBlue(image,ScaleLongToQuantum(pixel),q);

            p=PushLongPixel(quantum_info->endian,p,&pixel);

            SetPixelGreen(image,ScaleLongToQuantum(pixel),q);

            p=PushLongPixel(quantum_info->endian,p,&pixel);

            SetPixelRed(image,ScaleLongToQuantum(pixel),q);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

    }

    case 24:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          float

            pixel;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);

            SetPixelRed(image,ClampToQuantum(pixel),q);

            p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);

            SetPixelGreen(image,ClampToQuantum(pixel),q);

            p=PushQuantumFloat24Pixel(quantum_info,p,&pixel);

            SetPixelBlue(image,ClampToQuantum(pixel),q);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      magick_fallthrough;

    }

    case 64:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          double

            pixel;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushDoublePixel(quantum_info,p,&pixel);

            SetPixelRed(image,ClampToQuantum(pixel),q);

            p=PushDoublePixel(quantum_info,p,&pixel);

            SetPixelGreen(image,ClampToQuantum(pixel),q);

            p=PushDoublePixel(quantum_info,p,&pixel);

            SetPixelBlue(image,ClampToQuantum(pixel),q);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      magick_fallthrough;

    }

    default:

    {

      unsigned int

        pixel;

      range=GetQuantumRange(quantum_info->depth);

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

  }

}

static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,

  const MagickSizeType number_pixels,const unsigned char *magick_restrict p,

  Quantum *magick_restrict q)

{

  QuantumAny

    range;

  ssize_t

    x;

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

  assert(image->signature == MagickCoreSignature);

  switch (quantum_info->depth)

  {

    case 8:

    {

      unsigned char

        pixel;

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushCharPixel(p,&pixel);

        SetPixelBlue(image,ScaleCharToQuantum(pixel),q);

        p=PushCharPixel(p,&pixel);

        SetPixelGreen(image,ScaleCharToQuantum(pixel),q);

        p=PushCharPixel(p,&pixel);

        SetPixelRed(image,ScaleCharToQuantum(pixel),q);

        p=PushCharPixel(p,&pixel);

        SetPixelAlpha(image,ScaleCharToQuantum(pixel),q);

        p+=(ptrdiff_t) quantum_info->pad;

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

    case 10:

    {

      unsigned int

        pixel;

      pixel=0;

      if (quantum_info->pack == MagickFalse)

        {

          ssize_t

            i;

          size_t

            quantum;

          ssize_t

            n;

          n=0;

          quantum=0;

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            for (i=0; i < 4; i++)

            {

              switch (n % 3)

              {

                case 0:

                {

                  p=PushLongPixel(quantum_info->endian,p,&pixel);

                  quantum=(size_t) (ScaleShortToQuantum((unsigned short)

                    (((pixel >> 22) & 0x3ff) << 6)));

                  break;

                }

                case 1:

                {

                  quantum=(size_t) (ScaleShortToQuantum((unsigned short)

                    (((pixel >> 12) & 0x3ff) << 6)));

                  break;

                }

                case 2:

                {

                  quantum=(size_t) (ScaleShortToQuantum((unsigned short)

                    (((pixel >> 2) & 0x3ff) << 6)));

                  break;

                }

              }

              switch (i)

              {

                case 0: SetPixelRed(image,(Quantum) quantum,q); break;

                case 1: SetPixelGreen(image,(Quantum) quantum,q); break;

                case 2: SetPixelBlue(image,(Quantum) quantum,q); break;

                case 3: SetPixelAlpha(image,(Quantum) quantum,q); break;

              }

              n++;

            }

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }

      for (x=0; x < (ssize_t) number_pixels; x++)

      {

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelRed(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),q);

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelGreen(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),

          q);

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelBlue(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),

          q);

        p=PushQuantumPixel(quantum_info,p,&pixel);

        SetPixelAlpha(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),

          q);

        q+=(ptrdiff_t) GetPixelChannels(image);

      }

      break;

    }

    case 16:

    {

      unsigned short

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          for (x=0; x < (ssize_t) number_pixels; x++)

          {

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            SetPixelRed(image,ClampToQuantum((double) QuantumRange*(double)

              HalfToSinglePrecision(pixel)),q);

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            SetPixelGreen(image,ClampToQuantum((double) QuantumRange*(double)

              HalfToSinglePrecision(pixel)),q);

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            SetPixelBlue(image,ClampToQuantum((double) QuantumRange*(double)

              HalfToSinglePrecision(pixel)),q);

            p=PushShortPixel(quantum_info->endian,p,&pixel);

            SetPixelAlpha(image,ClampToQuantum((double) QuantumRange*(double)

              HalfToSinglePrecision(pixel)),q);

            p+=(ptrdiff_t) quantum_info->pad;

            q+=(ptrdiff_t) GetPixelChannels(image);

          }

          break;

        }