/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%                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               %

%                                                                             %

%                   EEEEE  X   X  PPPP    OOO   RRRR   TTTTT                  %

%                   E       X X   P   P  O   O  R   R    T                    %

%                   EEE      X    PPPP   O   O  RRRR     T                    %

%                   E       X X   P      O   O  R R      T                    %

%                   EEEEE  X   X  P       OOO   R  R     T                    %

%                                                                             %

%                 MagickCore Methods to Export 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/license/                                         %

%                                                                             %

%  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"

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

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

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  ExportQuantumPixels() transfers one or more pixel components from the image

%  pixel cache to a user supplied buffer.  The pixels are returned in network

%  byte order.  It returns the number of exported pixels.

%

%  The format of the ExportQuantumPixels method is:

%

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

%        QuantumInfo *quantum_info,const QuantumType quantum_type,

%        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 (RGB, RGBA,

%      etc).

%

%    o pixels:  The components are transferred to this buffer.

%

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

%

*/

static inline unsigned char *PopQuantumDoublePixel(QuantumInfo *quantum_info,

  const double pixel,unsigned char *magick_restrict pixels)

{

  double

    *p;

  unsigned char

    quantum[8];

  (void) memset(quantum,0,sizeof(quantum));

  p=(double *) quantum;

  *p=(double) (pixel*quantum_info->state.inverse_scale+quantum_info->minimum);

  if (quantum_info->endian == LSBEndian)

    {

      *pixels++=quantum[0];

      *pixels++=quantum[1];

      *pixels++=quantum[2];

      *pixels++=quantum[3];

      *pixels++=quantum[4];

      *pixels++=quantum[5];

      *pixels++=quantum[6];

      *pixels++=quantum[7];

      return(pixels);

    }

  *pixels++=quantum[7];

  *pixels++=quantum[6];

  *pixels++=quantum[5];

  *pixels++=quantum[4];

  *pixels++=quantum[3];

  *pixels++=quantum[2];

  *pixels++=quantum[1];

  *pixels++=quantum[0];

  return(pixels);

}

static inline unsigned char *PopQuantumFloatPixel(QuantumInfo *quantum_info,

  const float pixel,unsigned char *magick_restrict pixels)

{

  float

    *p;

  unsigned char

    quantum[4];

  (void) memset(quantum,0,sizeof(quantum));

  p=(float *) quantum;

  *p=(float) ((double) pixel*quantum_info->state.inverse_scale+

    quantum_info->minimum);

  if (quantum_info->endian == LSBEndian)

    {

      *pixels++=quantum[0];

      *pixels++=quantum[1];

      *pixels++=quantum[2];

      *pixels++=quantum[3];

      return(pixels);

    }

  *pixels++=quantum[3];

  *pixels++=quantum[2];

  *pixels++=quantum[1];

  *pixels++=quantum[0];

  return(pixels);

}

static inline unsigned char *PopQuantumPixel(QuantumInfo *quantum_info,

  const QuantumAny pixel,unsigned char *magick_restrict pixels)

{

  ssize_t

    i;

  size_t

    quantum_bits;

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

    quantum_info->state.bits=8U;

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

  {

    quantum_bits=(size_t) i;

    if (quantum_bits > quantum_info->state.bits)

      quantum_bits=quantum_info->state.bits;

    i-=(ssize_t) quantum_bits;

    if (i < 0)

      i=0;

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

      *pixels='\0';

    quantum_info->state.bits-=quantum_bits;

    *pixels|=(((pixel >> i) &~ (((QuantumAny) ~0UL) << quantum_bits)) <<

      quantum_info->state.bits);

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

      {

        pixels++;

        quantum_info->state.bits=8UL;

      }

  }

  return(pixels);

}

static inline unsigned char *PopQuantumLongPixel(QuantumInfo *quantum_info,

  const size_t pixel,unsigned char *magick_restrict pixels)

{

  ssize_t

    i;

  size_t

    quantum_bits;

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

    quantum_info->state.bits=32UL;

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

  {

    quantum_bits=(size_t) i;

    if (quantum_bits > quantum_info->state.bits)

      quantum_bits=quantum_info->state.bits;

    quantum_info->state.pixel|=(((pixel >> ((ssize_t) quantum_info->depth-i)) &

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

        quantum_info->state.bits));

    i-=(ssize_t) quantum_bits;

    quantum_info->state.bits-=quantum_bits;

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

      {

        pixels=PopLongPixel(quantum_info->endian,quantum_info->state.pixel,

          pixels);

        quantum_info->state.pixel=0U;

        quantum_info->state.bits=32U;

      }

  }

  return(pixels);

}

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

  const MagickSizeType number_pixels,const Quantum *magick_restrict p,

  unsigned char *magick_restrict q,PixelChannel channel)

{

  QuantumAny

    range;

  ssize_t

    x;

  p+=(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++)

      {

        pixel=ScaleQuantumToChar(*p);

        q=PopCharPixel(pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 16:

    {

      unsigned short

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

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

          {

            pixel=SinglePrecisionToHalf(QuantumScale*(*p));

            q=PopShortPixel(quantum_info->endian,pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=ScaleQuantumToShort(*p);

        q=PopShortPixel(quantum_info->endian,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 32:

    {

      unsigned int

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

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

          {

            q=PopQuantumFloatPixel(quantum_info,(float) *p,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=ScaleQuantumToLong(*p);

        q=PopLongPixel(quantum_info->endian,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 64:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

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

          {

            q=PopQuantumDoublePixel(quantum_info,(double) *p,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

      magick_fallthrough;

    }

    default:

    {

      range=GetQuantumRange(quantum_info->depth);

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

      {

        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(*p,range),q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

  }

}

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

  const MagickSizeType number_pixels,const Quantum *magick_restrict p,

  unsigned char *magick_restrict q,ExceptionInfo *exception)

{

  if (image->alpha_trait == UndefinedPixelTrait)

    {

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

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

      return;

    }

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

}

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

  const MagickSizeType number_pixels,const Quantum *magick_restrict p,

  unsigned char *magick_restrict q)

{

  QuantumAny

    range;

  ssize_t

    x;

  ssize_t

    bit;

  switch (quantum_info->depth)

  {

    case 8:

    {

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

      {

        q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);

        q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);

        q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      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++)

          {

            pixel=(unsigned int) (

              ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |

              ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |

              ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);

            q=PopLongPixel(quantum_info->endian,pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

      if (quantum_info->quantum == 32UL)

        {

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

          {

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),

              range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 12:

    {

      unsigned int

        pixel;

      range=GetQuantumRange(quantum_info->depth);

      if (quantum_info->pack == MagickFalse)

        {

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

          {

            switch (x % 3)

            {

              default:

              case 0:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),

                  range);

                break;

              }

              case 1:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),

                  range);

                break;

              }

              case 2:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),

                  range);

                p+=(ptrdiff_t) GetPixelChannels(image);

                break;

              }

            }

            q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),

              q);

            switch ((x+1) % 3)

            {

              default:

              case 0:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),

                  range);

                break;

              }

              case 1:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),

                  range);

                break;

              }

              case 2:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),

                  range);

                p+=(ptrdiff_t) GetPixelChannels(image);

                break;

              }

            }

            q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),

              q);

            q+=(ptrdiff_t) quantum_info->pad;

          }

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

          {

            switch ((x+bit) % 3)

            {

              default:

              case 0:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),

                  range);

                break;

              }

              case 1:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),

                  range);

                break;

              }

              case 2:

              {

                pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),

                  range);

                p+=(ptrdiff_t) GetPixelChannels(image);

                break;

              }

            }

            q=PopShortPixel(quantum_info->endian,(unsigned short) (pixel << 4),

              q);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          if (bit != 0)

            p+=(ptrdiff_t) GetPixelChannels(image);

          break;

        }

      if (quantum_info->quantum == 32UL)

        {

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

          {

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),

              range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 16:

    {

      unsigned short

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

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

          {

            pixel=SinglePrecisionToHalf(QuantumScale*(double)

              GetPixelBlue(image,p));

            q=PopShortPixel(quantum_info->endian,pixel,q);

            pixel=SinglePrecisionToHalf(QuantumScale*(double)

              GetPixelGreen(image,p));

            q=PopShortPixel(quantum_info->endian,pixel,q);

            pixel=SinglePrecisionToHalf(QuantumScale*(double)

              GetPixelRed(image,p));

            q=PopShortPixel(quantum_info->endian,pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));

        q=PopShortPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));

        q=PopShortPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToShort(GetPixelRed(image,p));

        q=PopShortPixel(quantum_info->endian,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 32:

    {

      unsigned int

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

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

          {

            q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);

            q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);

            q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));

        q=PopLongPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));

        q=PopLongPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToLong(GetPixelRed(image,p));

        q=PopLongPixel(quantum_info->endian,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 64:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

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

          {

            q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);

            q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);

            q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

      magick_fallthrough;

    }

    default:

    {

      range=GetQuantumRange(quantum_info->depth);

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

      {

        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),

          range),q);

        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),

          range),q);

        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),

          range),q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

  }

}

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

  const MagickSizeType number_pixels,const Quantum *magick_restrict p,

  unsigned char *magick_restrict q)

{

  QuantumAny

    range;

  ssize_t

    x;

  switch (quantum_info->depth)

  {

    case 8:

    {

      unsigned char

        pixel;

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

      {

        pixel=ScaleQuantumToChar(GetPixelBlue(image,p));

        q=PopCharPixel(pixel,q);

        pixel=ScaleQuantumToChar(GetPixelGreen(image,p));

        q=PopCharPixel(pixel,q);

        pixel=ScaleQuantumToChar(GetPixelRed(image,p));

        q=PopCharPixel(pixel,q);

        pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));

        q=PopCharPixel(pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 10:

    {

      unsigned int

        pixel;

      range=GetQuantumRange(quantum_info->depth);

      if (quantum_info->pack == MagickFalse)

        {

          ssize_t

            i;

          size_t

            quantum;

          ssize_t

            n;

          n=0;

          quantum=0;

          pixel=0;

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

          {

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

            {

              switch (i)

              {

                case 0: quantum=(size_t) GetPixelRed(image,p); break;

                case 1: quantum=(size_t) GetPixelGreen(image,p); break;

                case 2: quantum=(size_t) GetPixelBlue(image,p); break;

                case 3: quantum=(size_t) GetPixelAlpha(image,p); break;

              }

              switch (n % 3)

              {

                case 0:

                {

                  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,

                    range) << 22);

                  break;

                }

                case 1:

                {

                  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,

                    range) << 12);

                  break;

                }

                case 2:

                {

                  pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,

                    range) << 2);

                  q=PopLongPixel(quantum_info->endian,pixel,q);

                  pixel=0;

                  break;

                }

              }

              n++;

            }

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

      if (quantum_info->quantum == 32UL)

        {

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

          {

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),

              range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),

              range);

            q=PopQuantumLongPixel(quantum_info,pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);

        q=PopQuantumPixel(quantum_info,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 16:

    {

      unsigned short

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

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

          {

            pixel=SinglePrecisionToHalf(QuantumScale*(double)

              GetPixelBlue(image,p));

            q=PopShortPixel(quantum_info->endian,pixel,q);

            pixel=SinglePrecisionToHalf(QuantumScale*(double)

              GetPixelGreen(image,p));

            q=PopShortPixel(quantum_info->endian,pixel,q);

            pixel=SinglePrecisionToHalf(QuantumScale*(double)

              GetPixelRed(image,p));

            q=PopShortPixel(quantum_info->endian,pixel,q);

            pixel=SinglePrecisionToHalf(QuantumScale*(double)

              GetPixelAlpha(image,p));

            q=PopShortPixel(quantum_info->endian,pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=ScaleQuantumToShort(GetPixelBlue(image,p));

        q=PopShortPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToShort(GetPixelGreen(image,p));

        q=PopShortPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToShort(GetPixelRed(image,p));

        q=PopShortPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));

        q=PopShortPixel(quantum_info->endian,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 32:

    {

      unsigned int

        pixel;

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

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

          {

            float

              float_pixel;

            q=PopQuantumFloatPixel(quantum_info,(float) GetPixelRed(image,p),q);

            q=PopQuantumFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);

            q=PopQuantumFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);

            float_pixel=(float) GetPixelAlpha(image,p);

            q=PopQuantumFloatPixel(quantum_info,float_pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

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

      {

        pixel=ScaleQuantumToLong(GetPixelBlue(image,p));

        q=PopLongPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToLong(GetPixelGreen(image,p));

        q=PopLongPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToLong(GetPixelRed(image,p));

        q=PopLongPixel(quantum_info->endian,pixel,q);

        pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));

        q=PopLongPixel(quantum_info->endian,pixel,q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

    case 64:

    {

      if (quantum_info->format == FloatingPointQuantumFormat)

        {

          double

            pixel;

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

          {

            q=PopQuantumDoublePixel(quantum_info,(double) GetPixelRed(image,p),q);

            q=PopQuantumDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);

            q=PopQuantumDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);

            pixel=(double) GetPixelAlpha(image,p);

            q=PopQuantumDoublePixel(quantum_info,pixel,q);

            p+=(ptrdiff_t) GetPixelChannels(image);

            q+=(ptrdiff_t) quantum_info->pad;

          }

          break;

        }

      magick_fallthrough;

    }

    default:

    {

      range=GetQuantumRange(quantum_info->depth);

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

      {

        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlue(image,p),

          range),q);

        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelGreen(image,p),

          range),q);

        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelRed(image,p),

          range),q);

        q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelAlpha(image,p),

          range),q);

        p+=(ptrdiff_t) GetPixelChannels(image);

        q+=(ptrdiff_t) quantum_info->pad;

      }

      break;

    }

  }

}

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

  const MagickSizeType number_pixels,const Quantum *magick_restrict p,

  unsigned char *magick_restrict q)

{

  QuantumAny

    range;