43 #include "magick/studio.h"
44 #include "magick/blob.h"
45 #include "magick/blob-private.h"
46 #include "magick/cache.h"
47 #include "magick/cache-private.h"
48 #include "magick/color-private.h"
49 #include "magick/composite-private.h"
50 #include "magick/constitute.h"
51 #include "magick/exception.h"
52 #include "magick/exception-private.h"
53 #include "magick/geometry.h"
54 #include "magick/memory_.h"
55 #include "magick/memory-private.h"
56 #include "magick/pixel.h"
57 #include "magick/policy.h"
58 #include "magick/quantum.h"
59 #include "magick/quantum-private.h"
60 #include "magick/semaphore.h"
61 #include "magick/stream.h"
62 #include "magick/stream-private.h"
63 #include "magick/string_.h"
110 #if defined(__cplusplus) || defined(c_plusplus)
115 *GetVirtualPixelStream(
const Image *,
const VirtualPixelMethod,
const ssize_t,
118 static MagickBooleanType
123 *QueueAuthenticPixelsStream(
Image *,
const ssize_t,
const ssize_t,
const size_t,
126 #if defined(__cplusplus) || defined(c_plusplus)
157 stream_info=(
StreamInfo *) AcquireMagickMemory(
sizeof(*stream_info));
159 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
160 (void) memset(stream_info,0,
sizeof(*stream_info));
161 stream_info->pixels=(
unsigned char *) MagickAssumeAligned(
162 AcquireAlignedMemory(1,
sizeof(*stream_info->pixels)));
163 if (stream_info->pixels == (
unsigned char *) NULL)
164 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
165 stream_info->map=ConstantString(
"RGB");
166 stream_info->storage_type=CharPixel;
167 stream_info->stream=AcquireImage(image_info);
168 stream_info->signature=MagickCoreSignature;
195 static inline void RelinquishStreamPixels(
CacheInfo *cache_info)
197 assert(cache_info != (
CacheInfo *) NULL);
198 if (cache_info->pixels != NULL)
200 if (cache_info->mapped == MagickFalse)
201 cache_info->pixels=(
PixelPacket *) RelinquishAlignedMemory(
205 (void) UnmapBlob(cache_info->pixels,(
size_t) cache_info->length);
209 cache_info->mapped=MagickFalse;
210 cache_info->indexes=(IndexPacket *) NULL;
211 cache_info->length=0;
214 static void DestroyPixelStream(
Image *image)
222 assert(image != (
Image *) NULL);
223 assert(image->signature == MagickCoreSignature);
224 if (IsEventLogging() != MagickFalse)
225 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
227 assert(cache_info->signature == MagickCoreSignature);
229 LockSemaphoreInfo(cache_info->semaphore);
230 cache_info->reference_count--;
231 if (cache_info->reference_count == 0)
233 UnlockSemaphoreInfo(cache_info->semaphore);
234 if (destroy == MagickFalse)
236 RelinquishStreamPixels(cache_info);
237 if (cache_info->nexus_info != (
NexusInfo **) NULL)
238 cache_info->nexus_info=DestroyPixelCacheNexus(cache_info->nexus_info,
239 cache_info->number_threads);
241 DestroySemaphoreInfo(&cache_info->file_semaphore);
243 DestroySemaphoreInfo(&cache_info->semaphore);
244 cache_info=(
CacheInfo *) RelinquishAlignedMemory(cache_info);
273 assert(stream_info->signature == MagickCoreSignature);
274 if (IsEventLogging() != MagickFalse)
275 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
276 if (stream_info->map != (
char *) NULL)
277 stream_info->map=DestroyString(stream_info->map);
278 if (stream_info->pixels != (
unsigned char *) NULL)
279 stream_info->pixels=(
unsigned char *) RelinquishAlignedMemory(
280 stream_info->pixels);
281 if (stream_info->stream != (
Image *) NULL)
283 (void) CloseBlob(stream_info->stream);
284 stream_info->stream=DestroyImage(stream_info->stream);
286 if (stream_info->quantum_info != (
QuantumInfo *) NULL)
287 stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
288 stream_info->signature=(~MagickCoreSignature);
289 stream_info=(
StreamInfo *) RelinquishMagickMemory(stream_info);
316 static IndexPacket *GetAuthenticIndexesFromStream(
const Image *image)
321 assert(image != (
Image *) NULL);
322 assert(image->signature == MagickCoreSignature);
323 if (IsEventLogging() != MagickFalse)
324 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
326 assert(cache_info->signature == MagickCoreSignature);
327 return(cache_info->indexes);
363 const ssize_t y,
const size_t columns,
const size_t rows,
369 assert(image != (
Image *) NULL);
370 assert(image->signature == MagickCoreSignature);
371 if (IsEventLogging() != MagickFalse)
372 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
373 pixels=QueueAuthenticPixelsStream(image,x,y,columns,rows,exception);
405 assert(image != (
Image *) NULL);
406 assert(image->signature == MagickCoreSignature);
407 if (IsEventLogging() != MagickFalse)
408 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
410 assert(cache_info->signature == MagickCoreSignature);
411 return(cache_info->pixels);
445 static MagickBooleanType GetOneAuthenticPixelFromStream(
Image *image,
451 assert(image != (
Image *) NULL);
452 assert(image->signature == MagickCoreSignature);
453 *pixel=image->background_color;
454 pixels=GetAuthenticPixelsStream(image,x,y,1,1,exception);
494 static MagickBooleanType GetOneVirtualPixelFromStream(
const Image *image,
495 const VirtualPixelMethod virtual_pixel_method,
const ssize_t x,
const ssize_t y,
501 assert(image != (
Image *) NULL);
502 assert(image->signature == MagickCoreSignature);
503 *pixel=image->background_color;
504 pixels=GetVirtualPixelStream(image,virtual_pixel_method,x,y,1,1,exception);
533 MagickExport
const void *GetStreamInfoClientData(
StreamInfo *stream_info)
536 assert(stream_info->signature == MagickCoreSignature);
537 return(stream_info->client_data);
571 assert(image != (
Image *) NULL);
572 assert(image->signature == MagickCoreSignature);
573 if (IsEventLogging() != MagickFalse)
574 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
576 assert(cache_info->signature == MagickCoreSignature);
577 return(cache_info->pixels);
603 static const IndexPacket *GetVirtualIndexesFromStream(
const Image *image)
608 assert(image != (
Image *) NULL);
609 assert(image->signature == MagickCoreSignature);
610 if (IsEventLogging() != MagickFalse)
611 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
613 assert(cache_info->signature == MagickCoreSignature);
614 return(cache_info->indexes);
653 static inline MagickBooleanType AcquireStreamPixels(
CacheInfo *cache_info,
656 if (cache_info->length != (MagickSizeType) ((
size_t) cache_info->length))
658 cache_info->pixels=(
PixelPacket *) MagickAssumeAligned(
659 AcquireAlignedMemory(1,(
size_t) cache_info->length));
661 (
void) memset(cache_info->pixels,0,(
size_t) cache_info->length);
664 (void) ThrowMagickException(exception,GetMagickModule(),
665 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",
666 cache_info->filename);
673 const VirtualPixelMethod magick_unused(virtual_pixel_method),
const ssize_t x,
674 const ssize_t y,
const size_t columns,
const size_t rows,
689 magick_unreferenced(virtual_pixel_method);
694 assert(image != (
const Image *) NULL);
695 assert(image->signature == MagickCoreSignature);
696 if (IsEventLogging() != MagickFalse)
697 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
698 if ((image->columns == 0) || (image->rows == 0) || (x < 0) ||
699 (y < 0) || (x >= (ssize_t) image->columns) ||
700 (y >= (ssize_t) image->rows))
702 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
703 "ImageDoesNotContainTheStreamGeometry",
"`%s'",image->filename);
707 assert(cache_info->signature == MagickCoreSignature);
711 cache_info->active_index_channel=((image->storage_class == PseudoClass) ||
712 (image->colorspace == CMYKColorspace)) ? MagickTrue : MagickFalse;
713 number_pixels=(MagickSizeType) columns*rows;
715 if (cache_info->active_index_channel != MagickFalse)
716 length+=number_pixels*
sizeof(IndexPacket);
719 cache_info->length=length;
720 status=AcquireStreamPixels(cache_info,exception);
721 if (status == MagickFalse)
723 cache_info->length=0;
728 if (cache_info->length < length)
730 RelinquishStreamPixels(cache_info);
731 cache_info->length=length;
732 status=AcquireStreamPixels(cache_info,exception);
733 if (status == MagickFalse)
735 cache_info->length=0;
739 cache_info->indexes=(IndexPacket *) NULL;
740 if (cache_info->active_index_channel != MagickFalse)
741 cache_info->indexes=(IndexPacket *) (cache_info->pixels+number_pixels);
742 return(cache_info->pixels);
774 MagickExport MagickBooleanType OpenStream(
const ImageInfo *image_info,
780 (void) CopyMagickString(stream_info->stream->filename,filename,MaxTextExtent);
781 status=OpenBlob(image_info,stream_info->stream,WriteBinaryBlobMode,exception);
817 static inline MagickBooleanType ValidatePixelCacheMorphology(
818 const Image *magick_restrict image)
821 *magick_restrict cache_info;
827 if ((image->storage_class != cache_info->storage_class) ||
828 (image->colorspace != cache_info->colorspace) ||
829 (image->channels != cache_info->channels) ||
830 (image->columns != cache_info->columns) ||
831 (image->rows != cache_info->rows) ||
832 (cache_info->nexus_info == (
NexusInfo **) NULL))
837 static PixelPacket *QueueAuthenticPixelsStream(
Image *image,
const ssize_t x,
838 const ssize_t y,
const size_t columns,
const size_t rows,
859 assert(image != (
Image *) NULL);
860 if ((x < 0) || (y < 0) ||
861 ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
862 ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
863 (columns == 0) || (rows == 0))
865 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
866 "ImageDoesNotContainTheStreamGeometry",
"`%s'",image->filename);
869 stream_handler=GetBlobStreamHandler(image);
870 if (stream_handler == (StreamHandler) NULL)
872 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
873 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
877 assert(cache_info->signature == MagickCoreSignature);
878 if (ValidatePixelCacheMorphology(image) == MagickFalse)
880 if (cache_info->storage_class == UndefinedClass)
881 (void) stream_handler(image,(
const void *) NULL,(size_t)
882 cache_info->columns);
883 cache_info->storage_class=image->storage_class;
884 cache_info->colorspace=image->colorspace;
885 cache_info->channels=image->channels;
886 cache_info->columns=image->columns;
887 cache_info->rows=image->rows;
888 image->cache=cache_info;
893 cache_info->active_index_channel=((image->storage_class == PseudoClass) ||
894 (image->colorspace == CMYKColorspace)) ? MagickTrue : MagickFalse;
895 cache_info->columns=columns;
896 cache_info->rows=rows;
897 number_pixels=(MagickSizeType) columns*rows;
899 if (cache_info->active_index_channel != MagickFalse)
900 length+=number_pixels*
sizeof(IndexPacket);
903 cache_info->length=length;
904 status=AcquireStreamPixels(cache_info,exception);
905 if (status == MagickFalse)
907 cache_info->length=0;
912 if (cache_info->length < length)
914 RelinquishStreamPixels(cache_info);
915 cache_info->length=length;
916 status=AcquireStreamPixels(cache_info,exception);
917 if (status == MagickFalse)
919 cache_info->length=0;
923 cache_info->indexes=(IndexPacket *) NULL;
924 if (cache_info->active_index_channel != MagickFalse)
925 cache_info->indexes=(IndexPacket *) (cache_info->pixels+number_pixels);
926 return(cache_info->pixels);
957 MagickExport
Image *ReadStream(
const ImageInfo *image_info,StreamHandler stream,
972 assert(image_info != (
ImageInfo *) NULL);
973 assert(image_info->signature == MagickCoreSignature);
975 assert(exception->signature == MagickCoreSignature);
976 if (IsEventLogging() != MagickFalse)
977 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
978 image_info->filename);
979 read_info=CloneImageInfo(image_info);
980 read_info->cache=AcquirePixelCache(0);
981 GetPixelCacheMethods(&cache_methods);
982 cache_methods.get_virtual_pixel_handler=GetVirtualPixelStream;
983 cache_methods.get_virtual_pixels_handler=GetVirtualPixelsStream;
984 cache_methods.get_virtual_indexes_from_handler=GetVirtualIndexesFromStream;
985 cache_methods.get_authentic_pixels_handler=GetAuthenticPixelsStream;
986 cache_methods.queue_authentic_pixels_handler=QueueAuthenticPixelsStream;
987 cache_methods.sync_authentic_pixels_handler=SyncAuthenticPixelsStream;
988 cache_methods.get_authentic_pixels_from_handler=GetAuthenticPixelsFromStream;
989 cache_methods.get_authentic_indexes_from_handler=
990 GetAuthenticIndexesFromStream;
991 cache_methods.get_one_virtual_pixel_from_handler=GetOneVirtualPixelFromStream;
992 cache_methods.get_one_authentic_pixel_from_handler=
993 GetOneAuthenticPixelFromStream;
994 cache_methods.destroy_pixel_handler=DestroyPixelStream;
995 SetPixelCacheMethods(read_info->cache,&cache_methods);
996 read_info->stream=stream;
997 image=ReadImage(read_info,exception);
998 read_info=DestroyImageInfo(read_info);
1027 MagickExport
void SetStreamInfoClientData(
StreamInfo *stream_info,
1028 const void *client_data)
1031 assert(stream_info->signature == MagickCoreSignature);
1032 stream_info->client_data=client_data;
1059 MagickExport
void SetStreamInfoMap(
StreamInfo *stream_info,
const char *map)
1062 assert(stream_info->signature == MagickCoreSignature);
1063 (void) CloneString(&stream_info->map,map);
1091 MagickExport
void SetStreamInfoStorageType(
StreamInfo *stream_info,
1092 const StorageType storage_type)
1095 assert(stream_info->signature == MagickCoreSignature);
1096 stream_info->storage_type=storage_type;
1128 #if defined(__cplusplus) || defined(c_plusplus)
1132 static size_t WriteStreamImage(
const Image *image,
const void *pixels,
1133 const size_t columns)
1152 stream_info=(
StreamInfo *) image->client_data;
1153 switch (stream_info->storage_type)
1155 default: packet_size=
sizeof(char);
break;
1156 case CharPixel: packet_size=
sizeof(char);
break;
1157 case DoublePixel: packet_size=
sizeof(double);
break;
1158 case FloatPixel: packet_size=
sizeof(float);
break;
1159 case IntegerPixel: packet_size=
sizeof(int);
break;
1160 case LongPixel: packet_size=
sizeof(ssize_t);
break;
1161 case QuantumPixel: packet_size=
sizeof(Quantum);
break;
1162 case ShortPixel: packet_size=
sizeof(
unsigned short);
break;
1165 assert(cache_info->signature == MagickCoreSignature);
1166 packet_size*=strlen(stream_info->map);
1167 length=packet_size*cache_info->columns*cache_info->rows;
1168 if (image != stream_info->image)
1176 (void) RelinquishAlignedMemory(stream_info->pixels);
1177 stream_info->pixels=(
unsigned char *) MagickAssumeAligned(
1178 AcquireAlignedMemory(1,length));
1179 if (stream_info->pixels == (
unsigned char *) NULL)
1181 (void) memset(stream_info->pixels,0,length);
1182 stream_info->image=image;
1183 write_info=CloneImageInfo(stream_info->image_info);
1184 (void) SetImageInfo(write_info,1,stream_info->exception);
1185 if (write_info->extract != (
char *) NULL)
1186 (
void) ParseAbsoluteGeometry(write_info->extract,
1187 &stream_info->extract_info);
1189 write_info=DestroyImageInfo(write_info);
1191 extract_info=stream_info->extract_info;
1192 if ((extract_info.width == 0) || (extract_info.height == 0))
1197 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1198 count=WriteBlob(stream_info->stream,length,stream_info->pixels);
1200 return(count == 0 ? 0 : columns);
1202 if ((stream_info->y < extract_info.y) ||
1203 (stream_info->y >= (ssize_t) (extract_info.y+extract_info.height)))
1211 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1212 length=packet_size*extract_info.width;
1213 count=WriteBlob(stream_info->stream,length,stream_info->pixels+packet_size*
1216 return(count == 0 ? 0 : columns);
1219 #if defined(__cplusplus) || defined(c_plusplus)
1232 assert(image_info != (
const ImageInfo *) NULL);
1233 assert(image_info->signature == MagickCoreSignature);
1235 assert(stream_info->signature == MagickCoreSignature);
1237 if (IsEventLogging() != MagickFalse)
1238 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1239 image_info->filename);
1240 read_info=CloneImageInfo(image_info);
1241 stream_info->image_info=image_info;
1242 stream_info->quantum_info=AcquireQuantumInfo(image_info,(
Image *) NULL);
1243 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1245 read_info=DestroyImageInfo(read_info);
1246 return((
Image *) NULL);
1248 stream_info->exception=exception;
1249 read_info->client_data=(
void *) stream_info;
1250 image=ReadStream(read_info,&WriteStreamImage,exception);
1251 read_info=DestroyImageInfo(read_info);
1252 stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
1253 stream_info->quantum_info=AcquireQuantumInfo(image_info,image);
1254 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1255 image=DestroyImage(image);
1288 static MagickBooleanType StreamImagePixels(
const StreamInfo *stream_info,
1311 assert(stream_info->signature == MagickCoreSignature);
1312 assert(image != (
Image *) NULL);
1313 assert(image->signature == MagickCoreSignature);
1314 if (IsEventLogging() != MagickFalse)
1315 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1316 length=strlen(stream_info->map);
1317 quantum_map=(QuantumType *) AcquireQuantumMemory(length,
sizeof(*quantum_map));
1318 if (quantum_map == (QuantumType *) NULL)
1320 (void) ThrowMagickException(exception,GetMagickModule(),
1321 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1322 return(MagickFalse);
1324 (void) memset(quantum_map,0,length*
sizeof(*quantum_map));
1325 for (i=0; i < (ssize_t) length; i++)
1327 switch (stream_info->map[i])
1332 quantum_map[i]=AlphaQuantum;
1338 quantum_map[i]=BlueQuantum;
1344 quantum_map[i]=CyanQuantum;
1345 if (image->colorspace == CMYKColorspace)
1347 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1348 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1349 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1350 return(MagickFalse);
1355 quantum_map[i]=GreenQuantum;
1361 quantum_map[i]=IndexQuantum;
1367 quantum_map[i]=BlackQuantum;
1368 if (image->colorspace == CMYKColorspace)
1370 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1371 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1372 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1373 return(MagickFalse);
1378 quantum_map[i]=MagentaQuantum;
1379 if (image->colorspace == CMYKColorspace)
1381 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1382 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1383 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1384 return(MagickFalse);
1389 quantum_map[i]=OpacityQuantum;
1395 quantum_map[i]=UndefinedQuantum;
1401 quantum_map[i]=RedQuantum;
1407 quantum_map[i]=YellowQuantum;
1408 if (image->colorspace == CMYKColorspace)
1410 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1411 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1412 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1413 return(MagickFalse);
1417 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1418 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1419 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
1420 return(MagickFalse);
1424 quantum_info=stream_info->quantum_info;
1425 switch (stream_info->storage_type)
1432 q=(
unsigned char *) stream_info->pixels;
1433 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1435 p=GetAuthenticPixelQueue(image);
1438 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1440 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1441 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1442 *q++=ScaleQuantumToChar(GetPixelRed(p));
1447 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1449 p=GetAuthenticPixelQueue(image);
1452 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1454 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1455 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1456 *q++=ScaleQuantumToChar(GetPixelRed(p));
1457 *q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(p)));
1462 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1464 p=GetAuthenticPixelQueue(image);
1467 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1469 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1470 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1471 *q++=ScaleQuantumToChar(GetPixelRed(p));
1472 *q++=ScaleQuantumToChar((Quantum) 0);
1477 if (LocaleCompare(stream_info->map,
"I") == 0)
1479 p=GetAuthenticPixelQueue(image);
1482 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1484 *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1489 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1491 p=GetAuthenticPixelQueue(image);
1494 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1496 *q++=ScaleQuantumToChar(GetPixelRed(p));
1497 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1498 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1503 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1505 p=GetAuthenticPixelQueue(image);
1508 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1510 *q++=ScaleQuantumToChar(GetPixelRed(p));
1511 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1512 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1513 *q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(p)));
1518 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1520 p=GetAuthenticPixelQueue(image);
1523 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1525 *q++=ScaleQuantumToChar(GetPixelRed(p));
1526 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1527 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1528 *q++=ScaleQuantumToChar((Quantum) 0);
1533 p=GetAuthenticPixelQueue(image);
1536 indexes=GetVirtualIndexQueue(image);
1537 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1539 for (i=0; i < (ssize_t) length; i++)
1542 switch (quantum_map[i])
1547 *q=ScaleQuantumToChar(GetPixelRed(p));
1551 case MagentaQuantum:
1553 *q=ScaleQuantumToChar(GetPixelGreen(p));
1559 *q=ScaleQuantumToChar(GetPixelBlue(p));
1564 *q=ScaleQuantumToChar(GetPixelAlpha(p));
1567 case OpacityQuantum:
1569 *q=ScaleQuantumToChar(GetPixelOpacity(p));
1574 if (image->colorspace == CMYKColorspace)
1575 *q=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1580 *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1597 q=(
double *) stream_info->pixels;
1598 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1600 p=GetAuthenticPixelQueue(image);
1603 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1605 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1606 quantum_info->scale+quantum_info->minimum);
1607 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1608 quantum_info->scale+quantum_info->minimum);
1609 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1610 quantum_info->scale+quantum_info->minimum);
1615 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1617 p=GetAuthenticPixelQueue(image);
1620 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1622 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1623 quantum_info->scale+quantum_info->minimum);
1624 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1625 quantum_info->scale+quantum_info->minimum);
1626 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1627 quantum_info->scale+quantum_info->minimum);
1628 *q++=(double) ((QuantumScale*(
double) GetPixelAlpha(p))*
1629 quantum_info->scale+quantum_info->minimum);
1634 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1636 p=GetAuthenticPixelQueue(image);
1639 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1641 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1642 quantum_info->scale+quantum_info->minimum);
1643 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1644 quantum_info->scale+quantum_info->minimum);
1645 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1646 quantum_info->scale+quantum_info->minimum);
1652 if (LocaleCompare(stream_info->map,
"I") == 0)
1654 p=GetAuthenticPixelQueue(image);
1657 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1659 *q++=(double) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1660 quantum_info->scale+quantum_info->minimum);
1665 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1667 p=GetAuthenticPixelQueue(image);
1670 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1672 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1673 quantum_info->scale+quantum_info->minimum);
1674 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1675 quantum_info->scale+quantum_info->minimum);
1676 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1677 quantum_info->scale+quantum_info->minimum);
1682 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1684 p=GetAuthenticPixelQueue(image);
1687 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1689 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1690 quantum_info->scale+quantum_info->minimum);
1691 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1692 quantum_info->scale+quantum_info->minimum);
1693 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1694 quantum_info->scale+quantum_info->minimum);
1695 *q++=(double) ((QuantumScale*(
double) GetPixelAlpha(p))*
1696 quantum_info->scale+quantum_info->minimum);
1701 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1703 p=GetAuthenticPixelQueue(image);
1706 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1708 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1709 quantum_info->scale+quantum_info->minimum);
1710 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1711 quantum_info->scale+quantum_info->minimum);
1712 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1713 quantum_info->scale+quantum_info->minimum);
1719 p=GetAuthenticPixelQueue(image);
1722 indexes=GetVirtualIndexQueue(image);
1723 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1725 for (i=0; i < (ssize_t) length; i++)
1728 switch (quantum_map[i])
1733 *q=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1734 quantum_info->scale+quantum_info->minimum);
1738 case MagentaQuantum:
1740 *q=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1741 quantum_info->scale+quantum_info->minimum);
1747 *q=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1748 quantum_info->scale+quantum_info->minimum);
1753 *q=(double) ((QuantumScale*(
double) GetPixelAlpha(p))*
1754 quantum_info->scale+quantum_info->minimum);
1757 case OpacityQuantum:
1759 *q=(double) ((QuantumScale*(
double) GetPixelOpacity(p))*
1760 quantum_info->scale+quantum_info->minimum);
1765 if (image->colorspace == CMYKColorspace)
1766 *q=(double) ((QuantumScale*(
double) GetPixelIndex(indexes+x))*
1767 quantum_info->scale+quantum_info->minimum);
1772 *q=(double) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1773 quantum_info->scale+quantum_info->minimum);
1790 q=(
float *) stream_info->pixels;
1791 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1793 p=GetAuthenticPixelQueue(image);
1796 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1798 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1799 quantum_info->scale+quantum_info->minimum);
1800 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1801 quantum_info->scale+quantum_info->minimum);
1802 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1803 quantum_info->scale+quantum_info->minimum);
1808 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1810 p=GetAuthenticPixelQueue(image);
1813 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1815 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1816 quantum_info->scale+quantum_info->minimum);
1817 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1818 quantum_info->scale+quantum_info->minimum);
1819 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1820 quantum_info->scale+quantum_info->minimum);
1821 *q++=(float) ((QuantumScale*(
double) GetPixelAlpha(p))*
1822 quantum_info->scale+quantum_info->minimum);
1827 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1829 p=GetAuthenticPixelQueue(image);
1832 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1834 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1835 quantum_info->scale+quantum_info->minimum);
1836 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1837 quantum_info->scale+quantum_info->minimum);
1838 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1839 quantum_info->scale+quantum_info->minimum);
1845 if (LocaleCompare(stream_info->map,
"I") == 0)
1847 p=GetAuthenticPixelQueue(image);
1850 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1852 *q++=(float) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1853 quantum_info->scale+quantum_info->minimum);
1858 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1860 p=GetAuthenticPixelQueue(image);
1863 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1865 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1866 quantum_info->scale+quantum_info->minimum);
1867 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1868 quantum_info->scale+quantum_info->minimum);
1869 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1870 quantum_info->scale+quantum_info->minimum);
1875 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1877 p=GetAuthenticPixelQueue(image);
1880 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1882 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1883 quantum_info->scale+quantum_info->minimum);
1884 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1885 quantum_info->scale+quantum_info->minimum);
1886 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1887 quantum_info->scale+quantum_info->minimum);
1888 *q++=(float) ((QuantumScale*(
double) GetPixelAlpha(p))*
1889 quantum_info->scale+quantum_info->minimum);
1894 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1896 p=GetAuthenticPixelQueue(image);
1899 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1901 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1902 quantum_info->scale+quantum_info->minimum);
1903 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1904 quantum_info->scale+quantum_info->minimum);
1905 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1906 quantum_info->scale+quantum_info->minimum);
1912 p=GetAuthenticPixelQueue(image);
1915 indexes=GetVirtualIndexQueue(image);
1916 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1918 for (i=0; i < (ssize_t) length; i++)
1921 switch (quantum_map[i])
1926 *q=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1927 quantum_info->scale+quantum_info->minimum);
1931 case MagentaQuantum:
1933 *q=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1934 quantum_info->scale+quantum_info->minimum);
1940 *q=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1941 quantum_info->scale+quantum_info->minimum);
1946 *q=(float) ((QuantumScale*(
double) GetPixelAlpha(p))*
1947 quantum_info->scale+quantum_info->minimum);
1950 case OpacityQuantum:
1952 *q=(float) ((QuantumScale*(
double) GetPixelOpacity(p))*
1953 quantum_info->scale+quantum_info->minimum);
1958 if (image->colorspace == CMYKColorspace)
1959 *q=(float) ((QuantumScale*(
double) GetPixelIndex(indexes+x))*
1960 quantum_info->scale+quantum_info->minimum);
1965 *q=(float) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1966 quantum_info->scale+quantum_info->minimum);
1983 q=(
unsigned int *) stream_info->pixels;
1984 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1986 p=GetAuthenticPixelQueue(image);
1989 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1991 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1992 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1993 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1998 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2000 p=GetAuthenticPixelQueue(image);
2003 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2005 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2006 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2007 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2008 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelAlpha(p));
2013 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2015 p=GetAuthenticPixelQueue(image);
2018 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2020 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2021 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2022 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2028 if (LocaleCompare(stream_info->map,
"I") == 0)
2030 p=GetAuthenticPixelQueue(image);
2033 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2035 *q++=(
unsigned int) ScaleQuantumToLong(ClampToQuantum(
2036 GetPixelIntensity(image,p)));
2041 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2043 p=GetAuthenticPixelQueue(image);
2046 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2048 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2049 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2050 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2055 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2057 p=GetAuthenticPixelQueue(image);
2060 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2062 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2063 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2064 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2065 *q++=(
unsigned int) ScaleQuantumToLong((Quantum)
2066 (GetPixelAlpha(p)));
2071 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2073 p=GetAuthenticPixelQueue(image);
2076 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2078 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2079 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2080 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2086 p=GetAuthenticPixelQueue(image);
2089 indexes=GetVirtualIndexQueue(image);
2090 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2092 for (i=0; i < (ssize_t) length; i++)
2095 switch (quantum_map[i])
2100 *q=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2104 case MagentaQuantum:
2106 *q=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2112 *q=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2117 *q=(
unsigned int) ScaleQuantumToLong(GetPixelAlpha(p));
2120 case OpacityQuantum:
2122 *q=(
unsigned int) ScaleQuantumToLong(GetPixelOpacity(p));
2127 if (image->colorspace == CMYKColorspace)
2128 *q=(
unsigned int) ScaleQuantumToLong(GetPixelIndex(
2134 *q=(
unsigned int) ScaleQuantumToLong(ClampToQuantum(
2135 GetPixelIntensity(image,p)));
2152 q=(
size_t *) stream_info->pixels;
2153 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2155 p=GetAuthenticPixelQueue(image);
2158 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2160 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2161 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2162 *q++=ScaleQuantumToLong(GetPixelRed(p));
2167 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2169 p=GetAuthenticPixelQueue(image);
2172 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2174 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2175 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2176 *q++=ScaleQuantumToLong(GetPixelRed(p));
2177 *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p)));
2182 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2184 p=GetAuthenticPixelQueue(image);
2187 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2189 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2190 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2191 *q++=ScaleQuantumToLong(GetPixelRed(p));
2197 if (LocaleCompare(stream_info->map,
"I") == 0)
2199 p=GetAuthenticPixelQueue(image);
2202 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2204 *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2209 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2211 p=GetAuthenticPixelQueue(image);
2214 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2216 *q++=ScaleQuantumToLong(GetPixelRed(p));
2217 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2218 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2223 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2225 p=GetAuthenticPixelQueue(image);
2228 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2230 *q++=ScaleQuantumToLong(GetPixelRed(p));
2231 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2232 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2233 *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p)));
2238 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2240 p=GetAuthenticPixelQueue(image);
2243 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2245 *q++=ScaleQuantumToLong(GetPixelRed(p));
2246 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2247 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2253 p=GetAuthenticPixelQueue(image);
2256 indexes=GetVirtualIndexQueue(image);
2257 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2259 for (i=0; i < (ssize_t) length; i++)
2262 switch (quantum_map[i])
2267 *q=ScaleQuantumToLong(GetPixelRed(p));
2271 case MagentaQuantum:
2273 *q=ScaleQuantumToLong(GetPixelGreen(p));
2279 *q=ScaleQuantumToLong(GetPixelBlue(p));
2284 *q=ScaleQuantumToLong(GetPixelAlpha(p));
2287 case OpacityQuantum:
2289 *q=ScaleQuantumToLong(GetPixelOpacity(p));
2294 if (image->colorspace == CMYKColorspace)
2295 *q=ScaleQuantumToLong(GetPixelIndex(indexes+x));
2300 *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2317 q=(Quantum *) stream_info->pixels;
2318 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2320 p=GetAuthenticPixelQueue(image);
2323 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2325 *q++=GetPixelBlue(p);
2326 *q++=GetPixelGreen(p);
2327 *q++=GetPixelRed(p);
2332 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2334 p=GetAuthenticPixelQueue(image);
2337 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2339 *q++=GetPixelBlue(p);
2340 *q++=GetPixelGreen(p);
2341 *q++=GetPixelRed(p);
2342 *q++=(Quantum) (GetPixelAlpha(p));
2347 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2349 p=GetAuthenticPixelQueue(image);
2352 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2354 *q++=GetPixelBlue(p);
2355 *q++=GetPixelGreen(p);
2356 *q++=GetPixelRed(p);
2362 if (LocaleCompare(stream_info->map,
"I") == 0)
2364 p=GetAuthenticPixelQueue(image);
2367 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2369 *q++=ClampToQuantum(GetPixelIntensity(image,p));
2374 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2376 p=GetAuthenticPixelQueue(image);
2379 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2381 *q++=GetPixelRed(p);
2382 *q++=GetPixelGreen(p);
2383 *q++=GetPixelBlue(p);
2388 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2390 p=GetAuthenticPixelQueue(image);
2393 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2395 *q++=GetPixelRed(p);
2396 *q++=GetPixelGreen(p);
2397 *q++=GetPixelBlue(p);
2398 *q++=(Quantum) (GetPixelAlpha(p));
2403 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2405 p=GetAuthenticPixelQueue(image);
2408 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2410 *q++=GetPixelRed(p);
2411 *q++=GetPixelGreen(p);
2412 *q++=GetPixelBlue(p);
2418 p=GetAuthenticPixelQueue(image);
2421 indexes=GetVirtualIndexQueue(image);
2422 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2424 for (i=0; i < (ssize_t) length; i++)
2427 switch (quantum_map[i])
2436 case MagentaQuantum:
2438 *q=GetPixelGreen(p);
2449 *q=GetPixelAlpha(p);
2452 case OpacityQuantum:
2454 *q=GetPixelOpacity(p);
2459 if (image->colorspace == CMYKColorspace)
2460 *q=GetPixelIndex(indexes+x);
2465 *q=ClampToQuantum(GetPixelIntensity(image,p));
2482 q=(
unsigned short *) stream_info->pixels;
2483 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2485 p=GetAuthenticPixelQueue(image);
2488 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2490 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2491 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2492 *q++=ScaleQuantumToShort(GetPixelRed(p));
2497 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2499 p=GetAuthenticPixelQueue(image);
2502 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2504 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2505 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2506 *q++=ScaleQuantumToShort(GetPixelRed(p));
2507 *q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(p)));
2512 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2514 p=GetAuthenticPixelQueue(image);
2517 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2519 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2520 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2521 *q++=ScaleQuantumToShort(GetPixelRed(p));
2527 if (LocaleCompare(stream_info->map,
"I") == 0)
2529 p=GetAuthenticPixelQueue(image);
2532 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2534 *q++=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,
2540 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2542 p=GetAuthenticPixelQueue(image);
2545 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2547 *q++=ScaleQuantumToShort(GetPixelRed(p));
2548 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2549 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2554 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2556 p=GetAuthenticPixelQueue(image);
2559 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2561 *q++=ScaleQuantumToShort(GetPixelRed(p));
2562 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2563 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2564 *q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(p)));
2569 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2571 p=GetAuthenticPixelQueue(image);
2574 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2576 *q++=ScaleQuantumToShort(GetPixelRed(p));
2577 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2578 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2584 p=GetAuthenticPixelQueue(image);
2587 indexes=GetVirtualIndexQueue(image);
2588 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2590 for (i=0; i < (ssize_t) length; i++)
2593 switch (quantum_map[i])
2598 *q=ScaleQuantumToShort(GetPixelRed(p));
2602 case MagentaQuantum:
2604 *q=ScaleQuantumToShort(GetPixelGreen(p));
2610 *q=ScaleQuantumToShort(GetPixelBlue(p));
2615 *q=ScaleQuantumToShort(GetPixelAlpha(p));
2618 case OpacityQuantum:
2620 *q=ScaleQuantumToShort(GetPixelOpacity(p));
2625 if (image->colorspace == CMYKColorspace)
2626 *q=ScaleQuantumToShort(GetPixelIndex(indexes+x));
2631 *q=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,
2646 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2647 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2648 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
2652 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2682 static MagickBooleanType SyncAuthenticPixelsStream(
Image *image,
2694 assert(image != (
Image *) NULL);
2695 assert(image->signature == MagickCoreSignature);
2696 if (IsEventLogging() != MagickFalse)
2697 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2699 assert(cache_info->signature == MagickCoreSignature);
2700 stream_handler=GetBlobStreamHandler(image);
2701 if (stream_handler == (StreamHandler) NULL)
2703 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
2704 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
2705 return(MagickFalse);
2707 length=stream_handler(image,cache_info->pixels,(
size_t) cache_info->columns);
2708 return(length == cache_info->columns ? MagickTrue : MagickFalse);
2737 MagickExport MagickBooleanType WriteStream(
const ImageInfo *image_info,
2738 Image *image,StreamHandler stream)
2746 assert(image_info != (
ImageInfo *) NULL);
2747 assert(image_info->signature == MagickCoreSignature);
2748 assert(image != (
Image *) NULL);
2749 assert(image->signature == MagickCoreSignature);
2750 if (IsEventLogging() != MagickFalse)
2751 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2752 image_info->filename);
2753 write_info=CloneImageInfo(image_info);
2754 *write_info->magick=
'\0';
2755 write_info->stream=stream;
2756 status=WriteImage(write_info,image);
2757 write_info=DestroyImageInfo(write_info);