From 3b8b0b8b150e3f9bc338bb2c01af291269987f81 Mon Sep 17 00:00:00 2001
From: dirk <dirk@git.imagemagick.org>
Date: Sun, 8 Mar 2015 10:37:18 +0000
Subject: [PATCH] Added separate import and export methods for opacity.
---
MagickCore/quantum-export.c | 725 +++++++++++++++++++++++++++++++++---
MagickCore/quantum-import.c | 714 +++++++++++++++++++++++++++++++++--
2 files changed, 1360 insertions(+), 79 deletions(-)
diff --git a/MagickCore/quantum-export.c b/MagickCore/quantum-export.c
index b7608162b..21c9c452a 100644
--- a/MagickCore/quantum-export.c
+++ b/MagickCore/quantum-export.c
@@ -886,6 +886,250 @@ static void ExportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
}
}
+static void ExportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register 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(GetPixelOpacity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ register 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=GetPixelRed(image,p); break;
+ case 1: quantum=GetPixelGreen(image,p); break;
+ case 2: quantum=GetPixelBlue(image,p); break;
+ case 3: quantum=GetPixelOpacity(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+=GetPixelChannels(image);
+ q+=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(GetPixelOpacity(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=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(GetPixelOpacity(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ 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*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=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(GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
+ pixel=(float) GetPixelOpacity(image,p);
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=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(GetPixelOpacity(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
+ pixel=(double) GetPixelOpacity(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ 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(GetPixelOpacity(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
static void ExportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
@@ -1525,28 +1769,193 @@ static void ExportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
}
}
-static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
+static void ExportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const Quantum *restrict p,
unsigned char *restrict q,ExceptionInfo *exception)
{
- QuantumAny
- range;
-
register ssize_t
x;
- assert(exception != (ExceptionInfo *) NULL);
- assert(exception->signature == MagickSignature);
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
switch (quantum_info->depth)
{
- case 1:
+ case 8:
{
- register double
- threshold;
-
register unsigned char
- black,
- white;
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ 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*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlack(image,p),q);
+ pixel=(float) (GetPixelOpacity(image,p));
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlack(image,p),q);
+ pixel=(double) (GetPixelOpacity(image,p));
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ default:
+ {
+ QuantumAny
+ range;
+
+ 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);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelBlack(image,p),
+ range),q);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register double
+ threshold;
+
+ register unsigned char
+ black,
+ white;
ssize_t
bit;
@@ -3209,6 +3618,250 @@ static void ExportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
}
}
+static void ExportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ assert(exception != (ExceptionInfo *) NULL);
+ assert(exception->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelRed(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelOpacity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ register 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=GetPixelRed(image,p); break;
+ case 1: quantum=GetPixelGreen(image,p); break;
+ case 2: quantum=GetPixelBlue(image,p); break;
+ case 3: quantum=GetPixelOpacity(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+=GetPixelChannels(image);
+ q+=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(GetPixelOpacity(image,p),
+ range);
+ q=PopQuantumLongPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=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(GetPixelOpacity(image,p),range);
+ q=PopQuantumPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ 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*GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
+ q=PopShortPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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_info,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(quantum_info,(float) GetPixelBlue(image,p),q);
+ pixel=(float) GetPixelOpacity(image,p);
+ q=PopFloatPixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
+ q=PopLongPixel(quantum_info->endian,pixel,q);
+ p+=GetPixelChannels(image);
+ 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_info,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(quantum_info,(double) GetPixelBlue(image,p),q);
+ pixel=(double) GetPixelOpacity(image,p);
+ q=PopDoublePixel(quantum_info,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+ 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);
+ q=PopQuantumPixel(quantum_info,ScaleQuantumToAny(GetPixelOpacity(image,p),
+ range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
MagickExport size_t ExportQuantumPixels(const Image *image,
CacheView *image_view,QuantumInfo *quantum_info,
const QuantumType quantum_type,unsigned char *restrict pixels,
@@ -3283,21 +3936,6 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
q+=GetPixelChannels(image);
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
- (quantum_type == BGROQuantum))
- {
- register Quantum
- *restrict q;
-
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
- }
- }
if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
{
Quantum
@@ -3334,11 +3972,15 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
break;
}
case BGRAQuantum:
- case BGROQuantum:
{
ExportBGRAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
+ case BGROQuantum:
+ {
+ ExportBGROQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
case BlackQuantum:
{
ExportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
@@ -3356,11 +3998,15 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
break;
}
case CMYKAQuantum:
- case CMYKOQuantum:
{
ExportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
+ case CMYKOQuantum:
+ {
+ ExportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
case CbYCrYQuantum:
{
ExportCbYCrYQuantum(image,quantum_info,number_pixels,p,q,exception);
@@ -3410,12 +4056,16 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
break;
}
case RGBAQuantum:
- case RGBOQuantum:
case CbYCrAQuantum:
{
ExportRGBAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
+ case RGBOQuantum:
+ {
+ ExportRGBOQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
default:
break;
}
@@ -3438,20 +4088,5 @@ MagickExport size_t ExportQuantumPixels(const Image *image,
q+=GetPixelChannels(image);
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
- (quantum_type == BGROQuantum))
- {
- register Quantum
- *restrict q;
-
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
- }
- }
return(extent);
}
diff --git a/MagickCore/quantum-import.c b/MagickCore/quantum-import.c
index a1464b83c..b9c975c16 100644
--- a/MagickCore/quantum-import.c
+++ b/MagickCore/quantum-import.c
@@ -913,6 +913,240 @@ static void ImportBGRAQuantum(const Image *image,QuantumInfo *quantum_info,
}
}
+static void ImportBGROQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ 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);
+ SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
+ {
+ register 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: SetPixelOpacity(image,(Quantum) quantum,q); break;
+ }
+ n++;
+ }
+ p+=quantum_info->pad;
+ q+=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);
+ SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ q+=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(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=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=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ 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_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ 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=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ 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=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+ default:
+ {
+ 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);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
static void ImportBlackQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
@@ -1591,7 +1825,7 @@ static void ImportCMYKAQuantum(const Image *image,QuantumInfo *quantum_info,
}
}
-static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
+static void ImportCMYKOQuantum(const Image *image,QuantumInfo *quantum_info,
const MagickSizeType number_pixels,const unsigned char *restrict p,
Quantum *restrict q,ExceptionInfo *exception)
{
@@ -1601,28 +1835,209 @@ static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
register ssize_t
x;
- ssize_t
- bit;
-
unsigned int
pixel;
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
switch (quantum_info->depth)
{
- case 1:
+ case 8:
{
- register Quantum
- black,
- white;
+ unsigned char
+ pixel;
- black=0;
- white=QuantumRange;
- if (quantum_info->min_is_white != MagickFalse)
- {
- black=QuantumRange;
- white=0;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlack(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=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(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ 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_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlack(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ 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=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
+ p=PushDoublePixel(quantum_info,p,&pixel);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlack(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
+static void ImportGrayQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register Quantum
+ black,
+ white;
+
+ black=0;
+ white=QuantumRange;
+ if (quantum_info->min_is_white != MagickFalse)
+ {
+ black=QuantumRange;
+ white=0;
}
for (x=0; x < ((ssize_t) number_pixels-7); x+=8)
{
@@ -3438,6 +3853,240 @@ static void ImportRGBAQuantum(const Image *image,QuantumInfo *quantum_info,
}
}
+static void ImportRGBOQuantum(const Image *image,QuantumInfo *quantum_info,
+ const MagickSizeType number_pixels,const unsigned char *restrict p,
+ Quantum *restrict q,ExceptionInfo *exception)
+{
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ unsigned int
+ pixel;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushCharPixel(p,&pixel);
+ SetPixelRed(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelGreen(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelBlue(image,ScaleCharToQuantum(pixel),q);
+ p=PushCharPixel(p,&pixel);
+ SetPixelOpacity(image,ScaleCharToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ case 10:
+ {
+ pixel=0;
+ if (quantum_info->pack == MagickFalse)
+ {
+ register 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: SetPixelOpacity(image,(Quantum) quantum,q); break;
+ }
+ n++;
+ }
+ p+=quantum_info->pad;
+ q+=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);
+ SetPixelOpacity(image,ScaleShortToQuantum((unsigned short) (pixel << 6)),
+ q);
+ q+=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(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(QuantumRange*
+ HalfToSinglePrecision(pixel)),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleShortToQuantum(pixel),q);
+ p=PushShortPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ScaleShortToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ 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_info,p,&pixel);
+ SetPixelRed(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ClampToQuantum(pixel),q);
+ p=PushFloatPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelRed(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelGreen(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelBlue(image,ScaleLongToQuantum(pixel),q);
+ p=PushLongPixel(quantum_info->endian,p,&pixel);
+ SetPixelOpacity(image,ScaleLongToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ 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=PushDoublePixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ClampToQuantum(pixel),q);
+ p+=quantum_info->pad;
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelRed(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelGreen(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelBlue(image,ScaleAnyToQuantum(pixel,range),q);
+ p=PushQuantumPixel(quantum_info,p,&pixel);
+ SetPixelOpacity(image,ScaleAnyToQuantum(pixel,range),q);
+ q+=GetPixelChannels(image);
+ }
+ break;
+ }
+ }
+}
+
MagickExport size_t ImportQuantumPixels(const Image *image,
CacheView *image_view,QuantumInfo *quantum_info,
const QuantumType quantum_type,const unsigned char *restrict pixels,
@@ -3493,11 +4142,15 @@ MagickExport size_t ImportQuantumPixels(const Image *image,
break;
}
case BGRAQuantum:
- case BGROQuantum:
{
ImportBGRAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
+ case BGROQuantum:
+ {
+ ImportBGROQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
case BlackQuantum:
{
ImportBlackQuantum(image,quantum_info,number_pixels,p,q,exception);
@@ -3515,11 +4168,15 @@ MagickExport size_t ImportQuantumPixels(const Image *image,
break;
}
case CMYKAQuantum:
- case CMYKOQuantum:
{
ImportCMYKAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
+ case CMYKOQuantum:
+ {
+ ImportCMYKOQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
case CbYCrYQuantum:
{
ImportCbYCrYQuantum(image,quantum_info,number_pixels,p,q,exception);
@@ -3569,12 +4226,16 @@ MagickExport size_t ImportQuantumPixels(const Image *image,
break;
}
case RGBAQuantum:
- case RGBOQuantum:
case CbYCrAQuantum:
{
ImportRGBAQuantum(image,quantum_info,number_pixels,p,q,exception);
break;
}
+ case RGBOQuantum:
+ {
+ ImportRGBOQuantum(image,quantum_info,number_pixels,p,q,exception);
+ break;
+ }
default:
break;
}
@@ -3597,21 +4258,6 @@ MagickExport size_t ImportQuantumPixels(const Image *image,
q+=GetPixelChannels(image);
}
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
- (quantum_type == BGROQuantum))
- {
- register Quantum
- *restrict q;
-
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- SetPixelOpacity(image,GetPixelAlpha(image,q),q);
- q+=GetPixelChannels(image);
- }
- }
if (quantum_info->alpha_type == DisassociatedQuantumAlpha)
{
double
--
2.40.0