return(pixels);
}
-MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
- const QuantumInfo *quantum_info,const QuantumType quantum_type,
- unsigned char *pixels,ExceptionInfo *exception)
+static void ExportAlphaQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
{
EndianType
endian;
- MagickRealType
- alpha;
-
- MagickSizeType
- number_pixels;
-
QuantumAny
range;
- QuantumState
- quantum_state;
-
- register const Quantum
- *restrict p;
-
register ssize_t
x;
- register unsigned char
- *restrict q;
-
- size_t
- channels,
- extent;
-
- ssize_t
- bit;
-
- assert(image != (Image *) NULL);
- assert(image->signature == MagickSignature);
- if (image->debug != MagickFalse)
- (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
- assert(quantum_info != (QuantumInfo *) NULL);
- assert(quantum_info->signature == MagickSignature);
- if (pixels == (unsigned char *) NULL)
- pixels=GetQuantumPixels(quantum_info);
- if (image_view == (CacheView *) NULL)
- {
- number_pixels=GetImageExtent(image);
- p=GetVirtualPixelQueue(image);
- channels=GetPixelChannels(image);
- }
- else
- {
- number_pixels=GetCacheViewExtent(image_view);
- p=GetCacheViewVirtualPixelQueue(image_view);
- channels=GetPixelChannels(image);
- }
- if (quantum_info->alpha_type == AssociatedQuantumAlpha)
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- register Quantum
- *restrict q;
+ register unsigned char
+ pixel;
- /*
- Associate alpha.
- */
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
- for (x=0; x < (ssize_t) image->columns; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- alpha=QuantumScale*GetPixelAlpha(image,q);
- SetPixelRed(image,ClampToQuantum(alpha*GetPixelRed(image,q)),q);
- SetPixelGreen(image,ClampToQuantum(alpha*GetPixelGreen(image,q)),q);
- SetPixelBlue(image,ClampToQuantum(alpha*GetPixelBlue(image,q)),q);
- q++;
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
+ break;
}
- if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
- (quantum_type == BGROQuantum))
+ case 16:
{
- register Quantum
- *restrict q;
+ register unsigned short
+ pixel;
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetCacheViewAuthenticPixelQueue(image_view);
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q++;
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
+ break;
}
- if ((quantum_type == CbYCrQuantum) || (quantum_type == CbYCrAQuantum))
+ case 32:
{
- Quantum
- quantum;
-
- register Quantum
- *restrict q;
+ register unsigned int
+ pixel;
- q=GetAuthenticPixelQueue(image);
- if (image_view != (CacheView *) NULL)
- q=GetAuthenticPixelQueue(image);
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(&quantum_state,(float) GetPixelAlpha(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- quantum=GetPixelRed(image,q);
- SetPixelRed(image,GetPixelGreen(image,q),q);
- SetPixelGreen(image,quantum,q);
- q+=channels;
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
+ break;
}
- x=0;
- q=pixels;
- InitializeQuantumState(quantum_info,image->endian,&quantum_state);
- extent=GetQuantumExtent(image,quantum_info,quantum_type);
- endian=quantum_state.endian;
- switch (quantum_type)
- {
- case IndexQuantum:
+ case 64:
{
- if (image->storage_class != PseudoClass)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 1:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
- for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0x01) << 7);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 6);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 5);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 4);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 3);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 2);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 1);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 0);
- p+=channels;
- q++;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelAlpha(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
- if ((number_pixels % 8) != 0)
- {
- *q='\0';
- for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << (unsigned char) bit);
- p+=channels;
- }
- q++;
- }
break;
}
- case 4:
- {
- register unsigned char
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportBGRQuantum(const Image *image,const QuantumInfo *quantum_info,
+ QuantumState quantum_state,const MagickSizeType number_pixels,
+ const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ endian=quantum_state.endian;
+ 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+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ register unsigned int
+ pixel;
- for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0xf) << 0);
- p+=channels;
- q++;
+ pixel=(unsigned int) (
+ ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
+ ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
+ ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
- if ((number_pixels % 2) != 0)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- p+=channels;
- q++;
- }
break;
}
- case 8:
+ if (quantum_info->quantum == 32UL)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned int
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ switch (x % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
- GetPixelIndex(image,p)),q);
- p+=channels;
- q+=quantum_info->pad;
+ 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+=GetPixelChannels(image);
+ break;
}
- break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ switch ((x+1) % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelIndex(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
+ 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+=GetPixelChannels(image);
+ break;
}
- break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
- p+=channels;
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
q+=quantum_info->pad;
}
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ switch ((x+bit) % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
+ range);
+ break;
+ }
+ case 1:
{
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelIndex(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ break;
+ }
+ case 2:
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ range);
+ p+=GetPixelChannels(image);
+ break;
}
- break;
}
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ q+=quantum_info->pad;
+ }
+ if (bit != 0)
+ p+=GetPixelChannels(image);
+ break;
}
- default:
+ if (quantum_info->quantum == 32UL)
{
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- GetPixelIndex(image,p),q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,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_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case IndexAlphaQuantum:
+ case 16:
{
- if (image->storage_class != PseudoClass)
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColormappedImageRequired","`%s'",image->filename);
- return(extent);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
}
- switch (quantum_info->depth)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 1:
- {
- register unsigned char
- pixel;
-
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0x01) << 7);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 6);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 5);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 4);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 3);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 2);
- p+=channels;
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << 1);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << 0);
- p+=channels;
- q++;
- }
- if ((number_pixels % 4) != 0)
- {
- *q='\0';
- for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q|=((pixel & 0x01) << (unsigned char) (bit+4));
- pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
- TransparentAlpha ? 1 : 0);
- *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
- p+=channels;
- }
- q++;
- }
- break;
- }
- case 4:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels ; x++)
- {
- pixel=(unsigned char) GetPixelIndex(image,p);
- *q=((pixel & 0xf) << 4);
- pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
- *q|=((pixel & 0xf) << 0);
- p+=channels;
- q++;
- }
- break;
- }
- case 8:
- {
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(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++)
- {
- q=PopShortPixel(endian,(unsigned short)
- GetPixelIndex(image,p),q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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)
- GetPixelIndex(image,p),q);
- pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
-
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelIndex(image,p),q);
- pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- GetPixelIndex(image,p),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),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_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case BGRQuantum:
+ }
+}
+
+static void ExportBGRAQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- switch (quantum_info->depth)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
+ 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+=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++)
{
- q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 10:
- {
- register 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(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- if (quantum_info->quantum == 32UL)
+ for (i=0; i < 4; i++)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (i)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
+ case 0: quantum=GetPixelRed(image,p); break;
+ case 1: quantum=GetPixelGreen(image,p); break;
+ case 2: quantum=GetPixelBlue(image,p); break;
+ case 3: quantum=GetPixelAlpha(image,p); break;
}
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 12:
- {
- register unsigned int
- pixel;
-
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ switch (n % 3)
{
- switch (x % 3)
+ case 0:
{
- 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+=channels;
- break;
- }
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 22);
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- switch ((x+1) % 3)
+ case 1:
{
- 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+=channels;
- break;
- }
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 12);
+ 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)
+ case 2:
{
- 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+=channels;
- break;
- }
+ pixel|=(size_t) (ScaleQuantumToAny((Quantum) quantum,
+ range) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ pixel=0;
+ break;
}
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- if (bit != 0)
- p+=channels;
- 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_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
}
- 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=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,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(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(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++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- 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)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- p+=channels;
+ float
+ pixel;
+
+ q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ pixel=(float) GetPixelAlpha(image,p);
+ q=PopFloatPixel(&quantum_state,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(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case BGRAQuantum:
- case BGROQuantum:
+ case 64:
{
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ double
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+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ pixel=(double) GetPixelAlpha(image,p);
+ q=PopDoublePixel(&quantum_state,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;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- size_t
- quantum;
+static void ExportBlackQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
- ssize_t
- n;
+ QuantumAny
+ range;
- 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=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(endian,pixel,q);
- pixel=0;
- break;
- }
- }
- n++;
- }
- p+=channels;
- 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_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ register ssize_t
+ x;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelBlack(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=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(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++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+static void ExportBlueQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ endian=quantum_state.endian;
+ 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);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
+
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(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(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case GrayQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 1:
- {
- register Quantum
- threshold;
-
- register unsigned char
- black,
- white;
+ register unsigned int
+ pixel;
- black=0x00;
- white=0x01;
- if (quantum_info->min_is_white != MagickFalse)
- {
- black=0x01;
- white=0x00;
- }
- threshold=(Quantum) (QuantumRange/2);
- for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
- {
- *q='\0';
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 7;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 6;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 5;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 4;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 3;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 2;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 1;
- p+=channels;
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 0;
- p+=channels;
- q++;
- }
- if ((number_pixels % 8) != 0)
- {
- *q='\0';
- for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
- {
- *q|=(GetPixelIntensity(image,p) < threshold ? black : white) <<
- bit;
- p+=channels;
- }
- q++;
- }
- break;
- }
- case 4:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- p+=channels;
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q|=pixel >> 4;
- p+=channels;
- q++;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
- if ((number_pixels % 2) != 0)
- {
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- p+=channels;
- q++;
- }
break;
}
- case 8:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 10:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportCbYCrYQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ Quantum
+ cbcr[4];
+
+ register ssize_t
+ i,
+ x;
+
+ register unsigned int
+ pixel;
+
+ size_t
+ quantum;
+
+ ssize_t
+ n;
+
+ endian=quantum_state.endian;
+ n=0;
+ quantum=0;
+ switch (quantum_info->depth)
+ {
+ case 10:
+ {
+ if (quantum_info->pack == MagickFalse)
{
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
+ {
+ for (i=0; i < 4; i++)
{
- register unsigned int
- pixel;
-
- for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
+ switch (n % 3)
{
- pixel=(unsigned int) (
- ScaleQuantumToAny(GetPixelIntensity(image,p+2*channels),range) << 22 |
- ScaleQuantumToAny(GetPixelIntensity(image,p+channels),range) << 12 |
- ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=3*channels;
- q+=quantum_info->pad;
- }
- if (x < (ssize_t) number_pixels)
+ case 0:
{
- pixel=0U;
- if (x++ < (ssize_t) (number_pixels-1))
- pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+channels),
- range) << 12;
- if (x++ < (ssize_t) number_pixels)
- pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p),
- range) << 2;
- q=PopLongPixel(endian,pixel,q);
+ quantum=GetPixelRed(image,p);
+ break;
}
- break;
+ case 1:
+ {
+ quantum=GetPixelGreen(image,p);
+ break;
+ }
+ case 2:
+ {
+ quantum=GetPixelBlue(image,p);
+ break;
+ }
+ }
+ cbcr[i]=(Quantum) quantum;
+ n++;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- p+=channels;
+ pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
+ (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
+ (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 12:
- {
- register unsigned short
- pixel;
+ break;
+ }
+ default:
+ {
+ QuantumAny
+ range;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ for (x=0; x < (ssize_t) number_pixels; x+=2)
+ {
+ for (i=0; i < 4; i++)
+ {
+ switch (n % 3)
+ {
+ case 0:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
- p+=channels;
- q+=quantum_info->pad;
- }
+ quantum=GetPixelRed(image,p);
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 1:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
+ quantum=GetPixelGreen(image,p);
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 32:
- {
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ case 2:
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- float
- pixel;
-
- pixel=(float) GetPixelIntensity(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
+ quantum=GetPixelBlue(image,p);
break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
}
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
+ cbcr[i]=(Quantum) quantum;
+ n++;
+ }
+ range=GetQuantumRange(quantum_info->depth);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[1],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[0],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[2],range),q);
+ p+=GetPixelChannels(image);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[3],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[0],range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(cbcr[2],range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+static void ExportCMYKQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ register ssize_t
+ x;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ endian=quantum_state.endian;
+ 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(GetPixelBlack(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)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
+ q=PopShortPixel(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(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case GrayAlphaQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 1:
- {
- register Quantum
- threshold;
-
- register unsigned char
- black,
- pixel,
- white;
+ register unsigned int
+ pixel;
- black=0x00;
- white=0x01;
- if (quantum_info->min_is_white == MagickFalse)
- {
- black=0x01;
- white=0x00;
- }
- threshold=(Quantum) (QuantumRange/2);
- for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
- {
- *q='\0';
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 7;
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
- p+=channels;
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 5;
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
- p+=channels;
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 3;
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
- p+=channels;
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 1;
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
- p+=channels;
- q++;
- }
- if ((number_pixels % 4) != 0)
- {
- *q='\0';
- for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
- {
- *q|=(GetPixelIntensity(image,p) > threshold ? black : white) <<
- (7-bit);
- pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
- 0x00 : 0x01);
- *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
- (7-bit-1));
- p+=channels;
- }
- q++;
- }
- break;
- }
- case 4:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
- for (x=0; x < (ssize_t) number_pixels ; x++)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- *q=(((pixel >> 4) & 0xf) << 4);
- pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
- *q|=pixel & 0xf;
- p+=channels;
- q++;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case 8:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
- q=PopCharPixel(pixel,q);
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ }
+ default:
+ {
+ QuantumAny
+ range;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelIntensity(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportCMYKAQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ register ssize_t
+ x;
+
+ if (image->colorspace != CMYKColorspace)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColorSeparatedImageRequired","`%s'",image->filename);
+ return;
+ }
+ endian=quantum_state.endian;
+ 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(GetPixelBlack(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(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=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlack(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(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;
-
- pixel=(float) GetPixelIntensity(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- pixel=(float) (GetPixelAlpha(image,p));
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
-
- pixel=(double) GetPixelIntensity(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
+ float
+ pixel;
+
+ q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlack(image,p),q);
+ pixel=(float) (GetPixelAlpha(image,p));
+ q=PopFloatPixel(&quantum_state,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(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case RedQuantum:
- case CyanQuantum:
+ case 64:
{
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
+ double
pixel;
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelRed(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlack(image,p),q);
+ pixel=(double) (GetPixelAlpha(image,p));
+ q=PopDoublePixel(&quantum_state,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ }
+ default:
+ {
+ QuantumAny
+ range;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportGrayQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register Quantum
+ threshold;
+
+ register unsigned char
+ black,
+ white;
+
+ ssize_t
+ bit;
+
+ black=0x00;
+ white=0x01;
+ if (quantum_info->min_is_white != MagickFalse)
+ {
+ black=0x01;
+ white=0x00;
+ }
+ threshold=(Quantum) (QuantumRange/2);
+ for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ {
+ *q='\0';
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 7;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 6;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 5;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 4;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 3;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 2;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 1;
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << 0;
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 8) != 0)
+ {
+ *q='\0';
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
+ *q|=(GetPixelIntensity(image,p) < threshold ? black : white) << bit;
+ p+=GetPixelChannels(image);
}
- break;
+ q++;
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
+ {
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q|=pixel >> 4;
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 2) != 0)
+ {
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ q++;
}
- case 32:
+ break;
+ }
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 10:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
register unsigned int
pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelRed(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
+ for (x=0; x < (ssize_t) (number_pixels-2); x+=3)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ pixel=(unsigned int) (
+ ScaleQuantumToAny(GetPixelIntensity(image,p+2*GetPixelChannels(image)),range) << 22 |
+ ScaleQuantumToAny(GetPixelIntensity(image,p+GetPixelChannels(image)),range) << 12 |
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range) << 2);
q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ p+=3*GetPixelChannels(image);
q+=quantum_info->pad;
}
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
+ if (x < (ssize_t) number_pixels)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelRed(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
+ pixel=0U;
+ if (x++ < (ssize_t) (number_pixels-1))
+ pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p+GetPixelChannels(image)),
+ range) << 12;
+ if (x++ < (ssize_t) number_pixels)
+ pixel|=ScaleQuantumToAny(GetPixelIntensity(image,p),
+ range) << 2;
+ q=PopLongPixel(endian,pixel,q);
}
+ break;
}
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned short
+ pixel;
+
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- p+=channels;
+ pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ q=PopShortPixel(endian,(unsigned short) (pixel >> 4),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case GreenQuantum:
- case MagentaQuantum:
+ case 16:
{
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned short
+ pixel;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelGreen(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelIntensity(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ q=PopShortPixel(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++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ float
+ pixel;
+
+ pixel=(float) GetPixelIntensity(image,p);
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned int
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ double
+ pixel;
+
+ pixel=(double) GetPixelIntensity(image,p);
+ q=PopDoublePixel(&quantum_state,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportGrayAlphaQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register Quantum
+ threshold;
+
+ register unsigned char
+ black,
+ pixel,
+ white;
+
+ ssize_t
+ bit;
+
+ black=0x00;
+ white=0x01;
+ if (quantum_info->min_is_white == MagickFalse)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ black=0x01;
+ white=0x00;
}
- default:
+ threshold=(Quantum) (QuantumRange/2);
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ {
+ *q='\0';
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 7;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 6);
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 5;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 4);
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 3;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 2);
+ p+=GetPixelChannels(image);
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) << 1;
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 4) != 0)
{
- range=GetQuantumRange(quantum_info->depth);
- for (x=0; x < (ssize_t) number_pixels; x++)
+ *q='\0';
+ for (bit=0; bit <= (ssize_t) (number_pixels % 4); bit+=2)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- p+=channels;
- q+=quantum_info->pad;
+ *q|=(GetPixelIntensity(image,p) > threshold ? black : white) <<
+ (7-bit);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == OpaqueAlpha ?
+ 0x00 : 0x01);
+ *q|=(((int) pixel != 0 ? 0x00 : 0x01) << (unsigned char)
+ (7-bit-1));
+ p+=GetPixelChannels(image);
}
- break;
+ q++;
}
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels ; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ *q=(((pixel >> 4) & 0xf) << 4);
+ pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
+ *q|=pixel & 0xf;
+ p+=GetPixelChannels(image);
+ q++;
}
break;
}
- case BlueQuantum:
- case YellowQuantum:
+ case 8:
{
- switch (quantum_info->depth)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
- {
- register unsigned char
- pixel;
+ pixel=ScaleQuantumToChar(GetPixelIntensity(image,p));
+ q=PopCharPixel(pixel,q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
+ q=PopCharPixel(pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToChar(GetPixelBlue(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*
+ GetPixelIntensity(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelIntensity(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(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++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- 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)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- p+=channels;
+ float
+ pixel;
+
+ pixel=(float) GetPixelIntensity(image,p);
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ pixel=(float) (GetPixelAlpha(image,p));
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelIntensity(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case AlphaQuantum:
+ case 64:
{
- switch (quantum_info->depth)
- {
- case 8:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
+ double
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ pixel=(double) GetPixelIntensity(image,p);
+ q=PopDoublePixel(&quantum_state,pixel,q);
+ pixel=(double) (GetPixelAlpha(image,p));
+ q=PopDoublePixel(&quantum_state,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelIntensity(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- float
- pixel;
+static void ExportGreenQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
- pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 64:
- {
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- double
- pixel;
+ QuantumAny
+ range;
- pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ register ssize_t
+ x;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToChar(GetPixelGreen(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)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case OpacityQuantum:
+ case 32:
{
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned int
+ pixel;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),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++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelAlpha(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportIndexQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ if (image->storage_class != PseudoClass)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return;
+ }
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=((ssize_t) number_pixels-7); x > 0; x-=8)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0x01) << 7);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 6);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 5);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 4);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 3);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 2);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 1);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 8) != 0)
+ {
+ *q='\0';
+ for (bit=7; bit >= (ssize_t) (8-(number_pixels % 8)); bit--)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << (unsigned char) bit);
+ p+=GetPixelChannels(image);
}
- break;
+ q++;
}
- case 64:
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) (number_pixels-1) ; x+=2)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0xf) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 2) != 0)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelAlpha(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0xf) << 4);
+ p+=GetPixelChannels(image);
+ q++;
}
- default:
+ break;
+ }
+ case 8:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
+ q=PopShortPixel(endian,SinglePrecisionToHalf(QuantumScale*
+ GetPixelIndex(image,p)),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case BlackQuantum:
+ case 32:
{
- if (image->colorspace != CMYKColorspace)
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
}
- switch (quantum_info->depth)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
+ q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned char
- pixel;
-
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToChar(GetPixelBlack(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
+ }
+ default:
+ {
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ GetPixelIndex(image,p),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportIndexAlphaQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ if (image->storage_class != PseudoClass)
+ {
+ (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
+ "ColormappedImageRequired","`%s'",image->filename);
+ return;
+ }
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 1:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=((ssize_t) number_pixels-3); x > 0; x-=4)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0x01) << 7);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 6);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 5);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 4);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 3);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 2);
+ p+=GetPixelChannels(image);
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << 1);
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ if ((number_pixels % 4) != 0)
{
- register unsigned short
- pixel;
+ *q='\0';
+ for (bit=3; bit >= (ssize_t) (4-(number_pixels % 4)); bit-=2)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q|=((pixel & 0x01) << (unsigned char) (bit+4));
+ pixel=(unsigned char) (GetPixelAlpha(image,p) == (Quantum)
+ TransparentAlpha ? 1 : 0);
+ *q|=((pixel & 0x01) << (unsigned char) (bit+4-1));
+ p+=GetPixelChannels(image);
+ }
+ q++;
+ }
+ break;
+ }
+ case 4:
+ {
+ register unsigned char
+ pixel;
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ for (x=0; x < (ssize_t) number_pixels ; x++)
+ {
+ pixel=(unsigned char) GetPixelIndex(image,p);
+ *q=((pixel & 0xf) << 4);
+ pixel=(unsigned char) (16*QuantumScale*GetPixelAlpha(image,p)+0.5);
+ *q|=((pixel & 0xf) << 0);
+ p+=GetPixelChannels(image);
+ q++;
+ }
+ break;
+ }
+ case 8:
+ {
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopCharPixel((unsigned char) GetPixelIndex(image,p),q);
+ pixel=ScaleQuantumToChar(GetPixelAlpha(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=ScaleQuantumToShort(GetPixelBlack(image,p));
+ q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopShortPixel(endian,(unsigned short) GetPixelIndex(image,p),q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(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++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlack(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ float
+ pixel;
+
+ q=PopFloatPixel(&quantum_state,(float) GetPixelIndex(image,p),q);
+ pixel=(float) GetPixelAlpha(image,p);
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ p+=GetPixelChannels(image);
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)
- GetPixelBlack(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopLongPixel(endian,(unsigned int) GetPixelIndex(image,p),q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny((Quantum) GetPixelBlack(image,p),range),q);
- p+=channels;
+ double
+ pixel;
+
+ q=PopDoublePixel(&quantum_state,(double) GetPixelIndex(image,p),q);
+ pixel=(double) GetPixelAlpha(image,p);
+ q=PopDoublePixel(&quantum_state,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_state,quantum_info->depth,
+ GetPixelIndex(image,p),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case RGBQuantum:
- case CbYCrQuantum:
+ }
+}
+
+static void ExportOpacityQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- switch (quantum_info->depth)
+ register unsigned char
+ pixel;
+
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
+ 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++)
{
- q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
- q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelOpacity(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 10:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelOpacity(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 32:
+ {
+ register 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(endian,pixel,q);
- p+=channels;
- 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_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelOpacity(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 12:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelOpacity(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- register unsigned int
- pixel;
-
- range=GetQuantumRange(quantum_info->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(
- 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+=channels;
- break;
- }
- }
- q=PopShortPixel(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+=channels;
- 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(
- 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+=channels;
- break;
- }
- }
- q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
- q+=quantum_info->pad;
- }
- if (bit != 0)
- p+=channels;
- 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_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- 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_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelOpacity(image,p),
+ q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 16:
- {
- register unsigned short
- pixel;
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelOpacity(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+static void ExportRedQuantum(const Image *image,const QuantumInfo *quantum_info,
+ QuantumState quantum_state,const MagickSizeType number_pixels,
+ const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ endian=quantum_state.endian;
+ 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);
+ 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=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(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++)
- {
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ p+=GetPixelChannels(image);
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)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),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_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case RGBAQuantum:
- case RGBOQuantum:
- case CbYCrAQuantum:
+ }
+}
+
+static void ExportRGBQuantum(const Image *image,const QuantumInfo *quantum_info,
+ QuantumState quantum_state,const MagickSizeType number_pixels,
+ const Quantum *restrict p,unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ ssize_t
+ bit;
+
+ endian=quantum_state.endian;
+ switch (quantum_info->depth)
+ {
+ case 8:
{
- switch (quantum_info->depth)
+ for (x=0; x < (ssize_t) number_pixels; x++)
{
- case 8:
- {
- register unsigned char
- pixel;
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelRed(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelGreen(image,p)),q);
+ q=PopCharPixel(ScaleQuantumToChar(GetPixelBlue(image,p)),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)
+ {
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(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
+ pixel=(unsigned int) (
+ ScaleQuantumToAny(GetPixelRed(image,p),range) << 22 |
+ ScaleQuantumToAny(GetPixelGreen(image,p),range) << 12 |
+ ScaleQuantumToAny(GetPixelBlue(image,p),range) << 2);
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 10:
+ if (quantum_info->quantum == 32UL)
{
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,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_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 12:
+ {
+ register unsigned int
+ pixel;
- range=GetQuantumRange(quantum_info->depth);
- if (quantum_info->pack == MagickFalse)
+ range=GetQuantumRange(quantum_info->depth);
+ if (quantum_info->pack == MagickFalse)
+ {
+ for (x=0; x < (ssize_t) (3*number_pixels-1); x+=2)
+ {
+ switch (x % 3)
{
- 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++)
+ default:
+ case 0:
{
- 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=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(endian,pixel,q);
- pixel=0;
- break;
- }
- }
- n++;
- }
- p+=channels;
- q+=quantum_info->pad;
+ 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+=GetPixelChannels(image);
+ break;
}
- break;
}
- if (quantum_info->quantum == 32UL)
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
+ switch ((x+1) % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
+ break;
+ }
+ case 1:
+ {
pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
+ break;
+ }
+ case 2:
+ {
pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),
range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,
- q);
- p+=channels;
- q+=quantum_info->pad;
+ p+=GetPixelChannels(image);
+ break;
}
- break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
- range);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
- p+=channels;
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
q+=quantum_info->pad;
}
- break;
- }
- case 16:
- {
- register unsigned short
- pixel;
-
- if (quantum_info->format == FloatingPointQuantumFormat)
+ for (bit=0; bit < (ssize_t) (3*number_pixels % 2); bit++)
+ {
+ switch ((x+bit) % 3)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ default:
+ case 0:
{
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
+ 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+=GetPixelChannels(image);
+ break;
}
- break;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ q=PopShortPixel(endian,(unsigned short) (pixel << 4),q);
q+=quantum_info->pad;
}
+ if (bit != 0)
+ p+=GetPixelChannels(image);
break;
}
- case 32:
+ if (quantum_info->quantum == 32UL)
{
- 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)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- pixel=(float) GetPixelAlpha(image,p);
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,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++)
+ {
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 16:
+ {
+ register unsigned short
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- pixel=(double) GetPixelAlpha(image,p);
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
+ q=PopShortPixel(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(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case CMYKQuantum:
+ case 32:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned int
+ pixel;
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
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);
- p+=channels;
+ q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),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(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
+ }
+ default:
+ {
+ range=GetQuantumRange(quantum_info->depth);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ }
+}
+
+static void ExportRGBAQuantum(const Image *image,
+ const QuantumInfo *quantum_info,QuantumState quantum_state,
+ const MagickSizeType number_pixels,const Quantum *restrict p,
+ unsigned char *restrict q,ExceptionInfo *exception)
+{
+ EndianType
+ endian;
+
+ QuantumAny
+ range;
+
+ register ssize_t
+ x;
+
+ endian=quantum_state.endian;
+ 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(GetPixelAlpha(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 unsigned int
- pixel;
+ register ssize_t
+ i;
- if (quantum_info->format == FloatingPointQuantumFormat)
+ 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++)
{
- for (x=0; x < (ssize_t) number_pixels; x++)
+ switch (i)
{
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlack(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
+ case 0: quantum=GetPixelRed(image,p); break;
+ case 1: quantum=GetPixelGreen(image,p); break;
+ case 2: quantum=GetPixelBlue(image,p); break;
+ case 3: quantum=GetPixelAlpha(image,p); break;
}
- 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++;
}
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
+ if (quantum_info->quantum == 32UL)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlack(image,p),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
- p+=channels;
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelRed(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),
+ range);
+ q=PopQuantumLongPixel(&quantum_state,quantum_info->depth,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_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelGreen(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelBlue(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ pixel=(unsigned int) ScaleQuantumToAny(GetPixelAlpha(image,p),range);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case CMYKAQuantum:
- case CMYKOQuantum:
+ case 16:
{
- if (image->colorspace != CMYKColorspace)
- {
- (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
- "ColorSeparatedImageRequired","`%s'",image->filename);
- return(extent);
- }
- switch (quantum_info->depth)
- {
- case 8:
- {
- register unsigned char
- pixel;
+ register unsigned short
+ 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(GetPixelAlpha(image,p));
- q=PopCharPixel(pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- case 16:
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- 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(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelGreen(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlue(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelBlack(image,p));
- q=PopShortPixel(endian,pixel,q);
- pixel=SinglePrecisionToHalf(QuantumScale*
- GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelRed(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelGreen(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelBlue(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelBlack(image,p));
+ pixel=SinglePrecisionToHalf(QuantumScale*GetPixelAlpha(image,p));
q=PopShortPixel(endian,pixel,q);
- pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
- q=PopShortPixel(endian,pixel,q);
- p+=channels;
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 32:
- {
- register unsigned int
- pixel;
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToShort(GetPixelRed(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelGreen(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelBlue(image,p));
+ q=PopShortPixel(endian,pixel,q);
+ pixel=ScaleQuantumToShort(GetPixelAlpha(image,p));
+ q=PopShortPixel(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_state,(float)
- GetPixelRed(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelGreen(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlue(image,p),q);
- q=PopFloatPixel(&quantum_state,(float)
- GetPixelBlack(image,p),q);
- pixel=(float) (GetPixelAlpha(image,p));
- q=PopFloatPixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
+ if (quantum_info->format == FloatingPointQuantumFormat)
+ {
for (x=0; x < (ssize_t) number_pixels; x++)
{
- pixel=ScaleQuantumToLong(GetPixelRed(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelBlack(image,p));
- q=PopLongPixel(endian,pixel,q);
- pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
+ float
+ pixel;
+
+ q=PopFloatPixel(&quantum_state,(float) GetPixelRed(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelGreen(image,p),q);
+ q=PopFloatPixel(&quantum_state,(float) GetPixelBlue(image,p),q);
+ pixel=(float) GetPixelAlpha(image,p);
+ q=PopFloatPixel(&quantum_state,pixel,q);
+ p+=GetPixelChannels(image);
q+=quantum_info->pad;
}
break;
}
- case 64:
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ pixel=ScaleQuantumToLong(GetPixelRed(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelGreen(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelBlue(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ pixel=ScaleQuantumToLong(GetPixelAlpha(image,p));
+ q=PopLongPixel(endian,pixel,q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
+ }
+ break;
+ }
+ case 64:
+ {
+ if (quantum_info->format == FloatingPointQuantumFormat)
{
- if (quantum_info->format == FloatingPointQuantumFormat)
- {
- double
- pixel;
+ double
+ pixel;
- for (x=0; x < (ssize_t) number_pixels; x++)
- {
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelRed(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelGreen(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlue(image,p),q);
- q=PopDoublePixel(&quantum_state,(double)
- GetPixelBlack(image,p),q);
- pixel=(double) (GetPixelAlpha(image,p));
- q=PopDoublePixel(&quantum_state,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- }
- default:
- {
- range=GetQuantumRange(quantum_info->depth);
for (x=0; x < (ssize_t) number_pixels; x++)
{
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelRed(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelBlack(image,p),range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
- p+=channels;
+ q=PopDoublePixel(&quantum_state,(double) GetPixelRed(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelGreen(image,p),q);
+ q=PopDoublePixel(&quantum_state,(double) GetPixelBlue(image,p),q);
+ pixel=(double) GetPixelAlpha(image,p);
+ q=PopDoublePixel(&quantum_state,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_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelRed(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelGreen(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelBlue(image,p),range),q);
+ q=PopQuantumPixel(&quantum_state,quantum_info->depth,
+ ScaleQuantumToAny(GetPixelAlpha(image,p),range),q);
+ p+=GetPixelChannels(image);
+ q+=quantum_info->pad;
}
break;
}
- case CbYCrYQuantum:
- {
- Quantum
- cbcr[4];
+ }
+}
- register ssize_t
- i;
+MagickExport size_t ExportQuantumPixels(Image *image,CacheView *image_view,
+ const QuantumInfo *quantum_info,const QuantumType quantum_type,
+ unsigned char *pixels,ExceptionInfo *exception)
+{
+ MagickSizeType
+ number_pixels;
- register unsigned int
- pixel;
+ QuantumState
+ quantum_state;
- size_t
- quantum;
+ register const Quantum
+ *restrict p;
- ssize_t
- n;
+ register ssize_t
+ x;
- n=0;
- quantum=0;
- range=GetQuantumRange(quantum_info->depth);
- switch (quantum_info->depth)
+ register unsigned char
+ *restrict q;
+
+ size_t
+ extent;
+
+ assert(image != (Image *) NULL);
+ assert(image->signature == MagickSignature);
+ if (image->debug != MagickFalse)
+ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
+ assert(quantum_info != (QuantumInfo *) NULL);
+ assert(quantum_info->signature == MagickSignature);
+ if (pixels == (unsigned char *) NULL)
+ pixels=GetQuantumPixels(quantum_info);
+ if (image_view == (CacheView *) NULL)
+ {
+ number_pixels=GetImageExtent(image);
+ p=GetVirtualPixelQueue(image);
+ }
+ else
+ {
+ number_pixels=GetCacheViewExtent(image_view);
+ p=GetCacheViewVirtualPixelQueue(image_view);
+ }
+ if (quantum_info->alpha_type == AssociatedQuantumAlpha)
+ {
+ MagickRealType
+ Sa;
+
+ register Quantum
+ *restrict q;
+
+ /*
+ Associate alpha.
+ */
+ q=GetAuthenticPixelQueue(image);
+ if (image_view != (CacheView *) NULL)
+ q=GetCacheViewAuthenticPixelQueue(image_view);
+ for (x=0; x < (ssize_t) image->columns; x++)
{
- case 10:
- {
- if (quantum_info->pack == MagickFalse)
- {
- for (x=0; x < (ssize_t) number_pixels; x+=2)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- quantum=GetPixelRed(image,p);
- break;
- }
- case 1:
- {
- quantum=GetPixelGreen(image,p);
- break;
- }
- case 2:
- {
- quantum=GetPixelBlue(image,p);
- break;
- }
- }
- cbcr[i]=(Quantum) quantum;
- n++;
- }
- pixel=(unsigned int) ((size_t) (cbcr[1]) << 22 | (size_t)
- (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- pixel=(unsigned int) ((size_t) (cbcr[3]) << 22 | (size_t)
- (cbcr[0]) << 12 | (size_t) (cbcr[2]) << 2);
- q=PopLongPixel(endian,pixel,q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
- }
- break;
- }
- default:
+ register ssize_t
+ i;
+
+ Sa=QuantumScale*GetPixelAlpha(image,q);
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
- for (x=0; x < (ssize_t) number_pixels; x+=2)
- {
- for (i=0; i < 4; i++)
- {
- switch (n % 3)
- {
- case 0:
- {
- quantum=GetPixelRed(image,p);
- break;
- }
- case 1:
- {
- quantum=GetPixelGreen(image,p);
- break;
- }
- case 2:
- {
- quantum=GetPixelBlue(image,p);
- break;
- }
- }
- cbcr[i]=(Quantum) quantum;
- n++;
- }
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(cbcr[1],range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(cbcr[0],range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(cbcr[2],range),q);
- p+=channels;
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(cbcr[3],range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(cbcr[0],range),q);
- q=PopQuantumPixel(&quantum_state,quantum_info->depth,
- ScaleQuantumToAny(cbcr[2],range),q);
- p+=channels;
- q+=quantum_info->pad;
- }
- break;
+ PixelChannel
+ channel;
+
+ PixelTrait
+ traits;
+
+ channel=GetPixelChannelMapChannel(image,i);
+ traits=GetPixelChannelMapTraits(image,channel);
+ if ((traits & UpdatePixelTrait) != 0)
+ q[i]=ClampToQuantum(Sa*q[i]);
}
+ 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
+ quantum;
+
+ register Quantum
+ *restrict q;
+
+ q=GetAuthenticPixelQueue(image);
+ if (image_view != (CacheView *) NULL)
+ q=GetAuthenticPixelQueue(image);
+ for (x=0; x < (ssize_t) number_pixels; x++)
+ {
+ quantum=GetPixelRed(image,q);
+ SetPixelRed(image,GetPixelGreen(image,q),q);
+ SetPixelGreen(image,quantum,q);
+ q+=GetPixelChannels(image);
+ }
+ }
+ x=0;
+ q=pixels;
+ InitializeQuantumState(quantum_info,image->endian,&quantum_state);
+ extent=GetQuantumExtent(image,quantum_info,quantum_type);
+ switch (quantum_type)
+ {
+ case AlphaQuantum:
+ {
+ ExportAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case BGRQuantum:
+ {
+ ExportBGRQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case BGRAQuantum:
+ case BGROQuantum:
+ {
+ ExportBGRAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case BlackQuantum:
+ {
+ ExportBlackQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case BlueQuantum:
+ case YellowQuantum:
+ {
+ ExportBlueQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case CMYKQuantum:
+ {
+ ExportCMYKQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case CMYKAQuantum:
+ case CMYKOQuantum:
+ {
+ ExportCMYKAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case CbYCrYQuantum:
+ {
+ ExportCbYCrYQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case GrayQuantum:
+ {
+ ExportGrayQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case GrayAlphaQuantum:
+ {
+ ExportGrayAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case GreenQuantum:
+ case MagentaQuantum:
+ {
+ ExportGreenQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case IndexQuantum:
+ {
+ ExportIndexQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case IndexAlphaQuantum:
+ {
+ ExportIndexAlphaQuantum(image,quantum_info,quantum_state,number_pixels,p,
+ q,exception);
+ break;
+ }
+ case RedQuantum:
+ case CyanQuantum:
+ {
+ ExportRedQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case OpacityQuantum:
+ {
+ ExportOpacityQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case RGBQuantum:
+ case CbYCrQuantum:
+ {
+ ExportRGBQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
+ break;
+ }
+ case RGBAQuantum:
+ case RGBOQuantum:
+ case CbYCrAQuantum:
+ {
+ ExportRGBAQuantum(image,quantum_info,quantum_state,number_pixels,p,q,
+ exception);
break;
}
default:
quantum=GetPixelRed(image,q);
SetPixelRed(image,GetPixelGreen(image,q),q);
SetPixelGreen(image,quantum,q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
}
if ((quantum_type == RGBOQuantum) || (quantum_type == CMYKOQuantum) ||
for (x=0; x < (ssize_t) number_pixels; x++)
{
SetPixelAlpha(image,GetPixelAlpha(image,q),q);
- q+=channels;
+ q+=GetPixelChannels(image);
}
}
return(extent);
projects / imagemagick / commitdiff