(no commit message)

diff --git a/ChangeLog b/ChangeLog
index 58e47d18b6b7b73f6529ec70f12c0ce140412ce1..3c9a7299e3c64bb2963ac133f81e00a397105e90 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,8 @@
-2010-08-15  6.6.3-6 Cristy  <quetzlzacatenango@image...>
+2010-08-23  6.6.3-10 Cristy  <quetzlzacatenango@image...>
+  * Fixed bug in the raw BGRA coders (reference
+    http://www.imagemagick.org/discourse-server/viewtopic.php?f=3&t=16880).
+
+2010-08-15  6.6.3-7 Cristy  <quetzlzacatenango@image...>
   * Throw exception if image size differs for the compare program but the
     -subimage-search option is not specified.
 

diff --git a/magick/quantum-export.c b/magick/quantum-export.c
index 071cd89a8712a13ee38407b610a4b7944553f9b4..34210276daabafc596e311885203354f9e8a5327 100644 (file)
--- a/magick/quantum-export.c
+++ b/magick/quantum-export.c
@@ -310,7 +310,8 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         q++;
       }
     }
-  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
+  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+      (quantum_type == BGROQuantum))
     {
       register PixelPacket
         *restrict q;
@@ -677,6 +678,519 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
       }
       break;
     }
+    case BGRQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopCharPixel(ScaleQuantumToChar(GetBluePixelComponent(p)),q);
+            q=PopCharPixel(ScaleQuantumToChar(GetGreenPixelComponent(p)),q);
+            q=PopCharPixel(ScaleQuantumToChar(GetRedPixelComponent(p)),q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 10:
+        {
+          register unsigned int
+            pixel;
+
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) (ScaleQuantumToAny(p->red,range) << 22 |
+                  ScaleQuantumToAny(p->green,range) << 12 |
+                  ScaleQuantumToAny(p->blue,range) << 2);
+                q=PopLongPixel(endian,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 12:
+        {
+          register unsigned int
+            pixel;
+
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+              {
+                switch (x % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                    p++;
+                    break;
+                  }
+                }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                switch ((x+1) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                    p++;
+                    break;
+                  }
+                }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                q+=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(p->red,range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                    p++;
+                    break;
+                  }
+                }
+                q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+                q+=quantum_info->pad;
+              }
+              if (bit != 0)
+                p++;
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 16:
+        {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetBluePixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetGreenPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetRedPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 32:
+        {
+          register unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopFloatPixel(&quantum_state,(float) p->red,q);
+                q=PopFloatPixel(&quantum_state,(float) p->green,q);
+                q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double) p->red,q);
+                q=PopDoublePixel(&quantum_state,(double) p->green,q);
+                q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(image->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
+              p->red,range),q);
+            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
+              p->green,range),q);
+            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
+              p->blue,range),q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+      }
+      break;
+    }
+    case BGRAQuantum:
+    case BGROQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          register unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToChar(GetBluePixelComponent(p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetGreenPixelComponent(p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar(GetRedPixelComponent(p));
+            q=PopCharPixel(pixel,q);
+            pixel=ScaleQuantumToChar((Quantum) GetAlphaPixelComponent(p));
+            q=PopCharPixel(pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 10:
+        {
+          register unsigned int
+            pixel;
+
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              ssize_t
+                n;
+
+              register ssize_t
+                i;
+
+              size_t
+                quantum;
+
+              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=p->red; break;
+                    case 1: quantum=p->green; break;
+                    case 2: quantum=p->blue; break;
+                    case 3: quantum=(Quantum) (QuantumRange-p->opacity); 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(endian,pixel,q);
+                      pixel=0;
+                      break;
+                    }
+                  }
+                  n++;
+                }
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32UL)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
+                  p->opacity),range);
+                q=PopQuantumLongPixel(&quantum_state,image->depth,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=(unsigned int) ScaleQuantumToAny(p->red,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(p->green,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny(p->blue,range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            pixel=(unsigned int) ScaleQuantumToAny((Quantum) (QuantumRange-
+              p->opacity),range);
+            q=PopQuantumPixel(&quantum_state,image->depth,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 16:
+        {
+          register unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetBluePixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetGreenPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetRedPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                pixel=SinglePrecisionToHalf(QuantumScale*
+                  GetAlphaPixelComponent(p));
+                q=PopShortPixel(endian,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToShort(GetBluePixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetGreenPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort(GetRedPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            pixel=ScaleQuantumToShort((Quantum) GetAlphaPixelComponent(p));
+            q=PopShortPixel(endian,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 32:
+        {
+          register unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                float
+                  pixel;
+
+                q=PopFloatPixel(&quantum_state,(float) p->red,q);
+                q=PopFloatPixel(&quantum_state,(float) p->green,q);
+                q=PopFloatPixel(&quantum_state,(float) p->blue,q);
+                pixel=(float) GetAlphaPixelComponent(p);
+                q=PopFloatPixel(&quantum_state,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            pixel=ScaleQuantumToLong(GetBluePixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetGreenPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong(GetRedPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            pixel=ScaleQuantumToLong((Quantum) GetAlphaPixelComponent(p));
+            q=PopLongPixel(endian,pixel,q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                q=PopDoublePixel(&quantum_state,(double) p->red,q);
+                q=PopDoublePixel(&quantum_state,(double) p->green,q);
+                q=PopDoublePixel(&quantum_state,(double) p->blue,q);
+                pixel=(double) GetAlphaPixelComponent(p);
+                q=PopDoublePixel(&quantum_state,pixel,q);
+                p++;
+                q+=quantum_info->pad;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(image->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
+              GetBluePixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
+              GetGreenPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
+              GetRedPixelComponent(p),range),q);
+            q=PopQuantumPixel(&quantum_state,image->depth,ScaleQuantumToAny(
+              (Quantum) GetAlphaPixelComponent(p),range),q);
+            p++;
+            q+=quantum_info->pad;
+          }
+          break;
+        }
+      }
+      break;
+    }
     case GrayQuantum:
     {
       switch (quantum_info->depth)
@@ -2666,7 +3180,8 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
         q++;
       }
     }
-  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum))
+  if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
+      (quantum_type == BGROQuantum))
     {
       register PixelPacket
         *restrict q;

diff --git a/magick/quantum-import.c b/magick/quantum-import.c
index 0d299a985506fec4554d5da7d25a0669f285c401..242183b07803995b29f7c40a6586a077a5be2b7a 100644 (file)
--- a/magick/quantum-import.c
+++ b/magick/quantum-import.c
@@ -704,6 +704,511 @@ MagickExport size_t ImportQuantumPixels(Image *image,CacheView *image_view,
           CorruptImageError,"InvalidColormapIndex","`%s'",image->filename);
       break;
     }
+    case BGRQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushCharPixel(p,&pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+            SetOpacityPixelComponent(q,OpaqueOpacity);
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 10:
+        {
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushLongPixel(endian,p,&pixel);
+                q->red=ScaleAnyToQuantum((pixel >> 22) & 0x3ff,range);
+                q->green=ScaleAnyToQuantum((pixel >> 12) & 0x3ff,range);
+                q->blue=ScaleAnyToQuantum((pixel >> 2) & 0x3ff,range);
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          if (quantum_info->quantum == 32U)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+        case 12:
+        {
+          range=GetQuantumRange(image->depth);
+          if (quantum_info->pack == MagickFalse)
+            {
+              unsigned short
+                pixel;
+
+              for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                switch (x % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    q++;
+                    break;
+                  }
+                }
+                p=PushShortPixel(endian,p,&pixel);
+                switch ((x+1) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    q++;
+                    break;
+                  }
+                }
+                p+=quantum_info->pad;
+              }
+              for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                switch ((x+bit) % 3)
+                {
+                  default:
+                  case 0:
+                  {
+                    q->red=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    break;
+                  }
+                  case 1:
+                  {
+                    q->green=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    break;
+                  }
+                  case 2:
+                  {
+                    q->blue=ScaleAnyToQuantum((QuantumAny) (pixel >> 4),range);
+                    q++;
+                    break;
+                  }
+                }
+                p+=quantum_info->pad;
+              }
+              if (bit != 0)
+                p++;
+              break;
+            }
+          if (quantum_info->quantum == 32U)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                p=PushQuantumLongPixel(&quantum_state,image->depth,p,&pixel);
+                SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+        case 16:
+        {
+          unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                q->red=ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel));
+                p=PushShortPixel(endian,p,&pixel);
+                q->green=ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel));
+                p=PushShortPixel(endian,p,&pixel);
+                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushShortPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 32:
+        {
+          unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              float
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                q->red=ClampToQuantum(pixel);
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                q->green=ClampToQuantum(pixel);
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                q->blue=ClampToQuantum(pixel);
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushLongPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                q->red=ClampToQuantum(pixel);
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                q->green=ClampToQuantum(pixel);
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                q->blue=ClampToQuantum(pixel);
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(image->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+      }
+      break;
+    }
+    case BGRAQuantum:
+    case BGROQuantum:
+    {
+      switch (quantum_info->depth)
+      {
+        case 8:
+        {
+          unsigned char
+            pixel;
+
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushCharPixel(p,&pixel);
+            SetBluePixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetGreenPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            SetRedPixelComponent(q,ScaleCharToQuantum(pixel));
+            p=PushCharPixel(p,&pixel);
+            q->opacity=(Quantum) (QuantumRange-ScaleCharToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 10:
+        {
+          pixel=0;
+          if (quantum_info->pack == MagickFalse)
+            {
+              ssize_t
+                n;
+
+              register ssize_t
+                i;
+
+              size_t
+                quantum;
+
+              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(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: q->red=(Quantum) (quantum); break;
+                    case 1: q->green=(Quantum) (quantum); break;
+                    case 2: q->blue=(Quantum) (quantum); break;
+                    case 3: q->opacity=(Quantum) (QuantumRange-quantum); break;
+                  }
+                  n++;
+                }
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            q->red=ScaleShortToQuantum((unsigned short) (pixel << 6));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            q->green=ScaleShortToQuantum((unsigned short) (pixel << 6));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            q->blue=ScaleShortToQuantum((unsigned short) (pixel << 6));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(
+              (unsigned short) (pixel << 6)));
+            q++;
+          }
+          break;
+        }
+        case 16:
+        {
+          unsigned short
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushShortPixel(endian,p,&pixel);
+                q->red=ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel));
+                p=PushShortPixel(endian,p,&pixel);
+                q->green=ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel));
+                p=PushShortPixel(endian,p,&pixel);
+                q->blue=ClampToQuantum((MagickRealType) QuantumRange*
+                  HalfToSinglePrecision(pixel));
+                p=PushShortPixel(endian,p,&pixel);
+                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(
+                  (MagickRealType) QuantumRange*HalfToSinglePrecision(pixel)));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushShortPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleShortToQuantum(pixel));
+            p=PushShortPixel(endian,p,&pixel);
+            q->opacity=(Quantum) (QuantumRange-ScaleShortToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 32:
+        {
+          unsigned int
+            pixel;
+
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              float
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                q->red=ClampToQuantum(pixel);
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                q->green=ClampToQuantum(pixel);
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                q->blue=ClampToQuantum(pixel);
+                p=PushFloatPixel(&quantum_state,p,&pixel);
+                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushLongPixel(endian,p,&pixel);
+            SetBluePixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetGreenPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            SetRedPixelComponent(q,ScaleLongToQuantum(pixel));
+            p=PushLongPixel(endian,p,&pixel);
+            q->opacity=(Quantum) (QuantumRange-ScaleLongToQuantum(pixel));
+            p+=quantum_info->pad;
+            q++;
+          }
+          break;
+        }
+        case 64:
+        {
+          if (quantum_info->format == FloatingPointQuantumFormat)
+            {
+              double
+                pixel;
+
+              for (x=0; x < (ssize_t) number_pixels; x++)
+              {
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                q->red=ClampToQuantum(pixel);
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                q->green=ClampToQuantum(pixel);
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                q->blue=ClampToQuantum(pixel);
+                p=PushDoublePixel(&quantum_state,p,&pixel);
+                q->opacity=(Quantum) (QuantumRange-ClampToQuantum(pixel));
+                p+=quantum_info->pad;
+                q++;
+              }
+              break;
+            }
+        }
+        default:
+        {
+          range=GetQuantumRange(image->depth);
+          for (x=0; x < (ssize_t) number_pixels; x++)
+          {
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetBluePixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetGreenPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            SetRedPixelComponent(q,ScaleAnyToQuantum(pixel,range));
+            p=PushQuantumPixel(&quantum_state,image->depth,p,&pixel);
+            q->opacity=(Quantum) (QuantumRange-ScaleAnyToQuantum(pixel,range));
+            q++;
+          }
+          break;
+        }
+      }
+      break;
+    }
     case GrayQuantum:
     {
       switch (quantum_info->depth)

diff --git a/magick/quantum.h b/magick/quantum.h
index e78e4861d652366b4a0d6b0c9108e508da5977f3..aa4be3a9b7cfd276923004aa159d31bbfdec1842 100644 (file)
--- a/magick/quantum.h
+++ b/magick/quantum.h
@@ -76,7 +76,8 @@ typedef enum
   CbYCrQuantum,
   CbYCrAQuantum,
   CMYKOQuantum,
-  BGRQuantum
+  BGRQuantum,
+  BGROQuantum
 } QuantumType;
 
 typedef struct _QuantumInfo