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 ((x < 0) || (y < 0) ||
699 ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
700 ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
701 (columns == 0) || (rows == 0))
703 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
704 "ImageDoesNotContainTheStreamGeometry",
"`%s'",image->filename);
708 assert(cache_info->signature == MagickCoreSignature);
712 cache_info->active_index_channel=((image->storage_class == PseudoClass) ||
713 (image->colorspace == CMYKColorspace)) ? MagickTrue : MagickFalse;
714 number_pixels=(MagickSizeType) columns*rows;
716 if (cache_info->active_index_channel != MagickFalse)
717 length+=number_pixels*
sizeof(IndexPacket);
720 cache_info->length=length;
721 status=AcquireStreamPixels(cache_info,exception);
722 if (status == MagickFalse)
724 cache_info->length=0;
729 if (cache_info->length < length)
731 RelinquishStreamPixels(cache_info);
732 cache_info->length=length;
733 status=AcquireStreamPixels(cache_info,exception);
734 if (status == MagickFalse)
736 cache_info->length=0;
740 cache_info->indexes=(IndexPacket *) NULL;
741 if (cache_info->active_index_channel != MagickFalse)
742 cache_info->indexes=(IndexPacket *) (cache_info->pixels+number_pixels);
743 return(cache_info->pixels);
775 MagickExport MagickBooleanType OpenStream(
const ImageInfo *image_info,
781 (void) CopyMagickString(stream_info->stream->filename,filename,MaxTextExtent);
782 status=OpenBlob(image_info,stream_info->stream,WriteBinaryBlobMode,exception);
818 static inline MagickBooleanType ValidatePixelCacheMorphology(
819 const Image *magick_restrict image)
822 *magick_restrict cache_info;
828 if ((image->storage_class != cache_info->storage_class) ||
829 (image->colorspace != cache_info->colorspace) ||
830 (image->channels != cache_info->channels) ||
831 (image->columns != cache_info->columns) ||
832 (image->rows != cache_info->rows) ||
833 (cache_info->nexus_info == (
NexusInfo **) NULL))
838 static PixelPacket *QueueAuthenticPixelsStream(
Image *image,
const ssize_t x,
839 const ssize_t y,
const size_t columns,
const size_t rows,
860 assert(image != (
Image *) NULL);
861 if ((x < 0) || (y < 0) ||
862 ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
863 ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
864 (columns == 0) || (rows == 0))
866 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
867 "ImageDoesNotContainTheStreamGeometry",
"`%s'",image->filename);
870 stream_handler=GetBlobStreamHandler(image);
871 if (stream_handler == (StreamHandler) NULL)
873 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
874 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
878 assert(cache_info->signature == MagickCoreSignature);
879 if (ValidatePixelCacheMorphology(image) == MagickFalse)
881 if (cache_info->storage_class == UndefinedClass)
882 (void) stream_handler(image,(
const void *) NULL,(size_t)
883 cache_info->columns);
884 cache_info->storage_class=image->storage_class;
885 cache_info->colorspace=image->colorspace;
886 cache_info->channels=image->channels;
887 cache_info->columns=image->columns;
888 cache_info->rows=image->rows;
889 image->cache=cache_info;
894 cache_info->active_index_channel=((image->storage_class == PseudoClass) ||
895 (image->colorspace == CMYKColorspace)) ? MagickTrue : MagickFalse;
896 cache_info->columns=columns;
897 cache_info->rows=rows;
898 number_pixels=(MagickSizeType) columns*rows;
900 if (cache_info->active_index_channel != MagickFalse)
901 length+=number_pixels*
sizeof(IndexPacket);
904 cache_info->length=length;
905 status=AcquireStreamPixels(cache_info,exception);
906 if (status == MagickFalse)
908 cache_info->length=0;
913 if (cache_info->length < length)
915 RelinquishStreamPixels(cache_info);
916 cache_info->length=length;
917 status=AcquireStreamPixels(cache_info,exception);
918 if (status == MagickFalse)
920 cache_info->length=0;
924 cache_info->indexes=(IndexPacket *) NULL;
925 if (cache_info->active_index_channel != MagickFalse)
926 cache_info->indexes=(IndexPacket *) (cache_info->pixels+number_pixels);
927 return(cache_info->pixels);
958 MagickExport
Image *ReadStream(
const ImageInfo *image_info,StreamHandler stream,
973 assert(image_info != (
ImageInfo *) NULL);
974 assert(image_info->signature == MagickCoreSignature);
976 assert(exception->signature == MagickCoreSignature);
977 if (IsEventLogging() != MagickFalse)
978 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
979 image_info->filename);
980 read_info=CloneImageInfo(image_info);
981 read_info->cache=AcquirePixelCache(0);
982 GetPixelCacheMethods(&cache_methods);
983 cache_methods.get_virtual_pixel_handler=GetVirtualPixelStream;
984 cache_methods.get_virtual_pixels_handler=GetVirtualPixelsStream;
985 cache_methods.get_virtual_indexes_from_handler=GetVirtualIndexesFromStream;
986 cache_methods.get_authentic_pixels_handler=GetAuthenticPixelsStream;
987 cache_methods.queue_authentic_pixels_handler=QueueAuthenticPixelsStream;
988 cache_methods.sync_authentic_pixels_handler=SyncAuthenticPixelsStream;
989 cache_methods.get_authentic_pixels_from_handler=GetAuthenticPixelsFromStream;
990 cache_methods.get_authentic_indexes_from_handler=
991 GetAuthenticIndexesFromStream;
992 cache_methods.get_one_virtual_pixel_from_handler=GetOneVirtualPixelFromStream;
993 cache_methods.get_one_authentic_pixel_from_handler=
994 GetOneAuthenticPixelFromStream;
995 cache_methods.destroy_pixel_handler=DestroyPixelStream;
996 SetPixelCacheMethods(read_info->cache,&cache_methods);
997 read_info->stream=stream;
998 image=ReadImage(read_info,exception);
999 read_info=DestroyImageInfo(read_info);
1028 MagickExport
void SetStreamInfoClientData(
StreamInfo *stream_info,
1029 const void *client_data)
1032 assert(stream_info->signature == MagickCoreSignature);
1033 stream_info->client_data=client_data;
1060 MagickExport
void SetStreamInfoMap(
StreamInfo *stream_info,
const char *map)
1063 assert(stream_info->signature == MagickCoreSignature);
1064 (void) CloneString(&stream_info->map,map);
1092 MagickExport
void SetStreamInfoStorageType(
StreamInfo *stream_info,
1093 const StorageType storage_type)
1096 assert(stream_info->signature == MagickCoreSignature);
1097 stream_info->storage_type=storage_type;
1129 #if defined(__cplusplus) || defined(c_plusplus)
1133 static size_t WriteStreamImage(
const Image *image,
const void *pixels,
1134 const size_t columns)
1153 stream_info=(
StreamInfo *) image->client_data;
1154 switch (stream_info->storage_type)
1156 default: packet_size=
sizeof(char);
break;
1157 case CharPixel: packet_size=
sizeof(char);
break;
1158 case DoublePixel: packet_size=
sizeof(double);
break;
1159 case FloatPixel: packet_size=
sizeof(float);
break;
1160 case IntegerPixel: packet_size=
sizeof(int);
break;
1161 case LongPixel: packet_size=
sizeof(ssize_t);
break;
1162 case QuantumPixel: packet_size=
sizeof(Quantum);
break;
1163 case ShortPixel: packet_size=
sizeof(
unsigned short);
break;
1166 assert(cache_info->signature == MagickCoreSignature);
1167 packet_size*=strlen(stream_info->map);
1168 length=packet_size*cache_info->columns*cache_info->rows;
1169 if (image != stream_info->image)
1177 (void) RelinquishAlignedMemory(stream_info->pixels);
1178 stream_info->pixels=(
unsigned char *) MagickAssumeAligned(
1179 AcquireAlignedMemory(1,length));
1180 if (stream_info->pixels == (
unsigned char *) NULL)
1182 (void) memset(stream_info->pixels,0,length);
1183 stream_info->image=image;
1184 write_info=CloneImageInfo(stream_info->image_info);
1185 (void) SetImageInfo(write_info,1,stream_info->exception);
1186 if (write_info->extract != (
char *) NULL)
1187 (
void) ParseAbsoluteGeometry(write_info->extract,
1188 &stream_info->extract_info);
1190 write_info=DestroyImageInfo(write_info);
1192 extract_info=stream_info->extract_info;
1193 if ((extract_info.width == 0) || (extract_info.height == 0))
1198 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1199 count=WriteBlob(stream_info->stream,length,stream_info->pixels);
1201 return(count == 0 ? 0 : columns);
1203 if ((stream_info->y < extract_info.y) ||
1204 (stream_info->y >= (ssize_t) (extract_info.y+extract_info.height)))
1212 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1213 length=packet_size*extract_info.width;
1214 count=WriteBlob(stream_info->stream,length,stream_info->pixels+packet_size*
1217 return(count == 0 ? 0 : columns);
1220 #if defined(__cplusplus) || defined(c_plusplus)
1233 assert(image_info != (
const ImageInfo *) NULL);
1234 assert(image_info->signature == MagickCoreSignature);
1236 assert(stream_info->signature == MagickCoreSignature);
1238 if (IsEventLogging() != MagickFalse)
1239 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1240 image_info->filename);
1241 read_info=CloneImageInfo(image_info);
1242 stream_info->image_info=image_info;
1243 stream_info->quantum_info=AcquireQuantumInfo(image_info,(
Image *) NULL);
1244 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1246 read_info=DestroyImageInfo(read_info);
1247 return((
Image *) NULL);
1249 stream_info->exception=exception;
1250 read_info->client_data=(
void *) stream_info;
1251 image=ReadStream(read_info,&WriteStreamImage,exception);
1252 read_info=DestroyImageInfo(read_info);
1253 stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
1254 stream_info->quantum_info=AcquireQuantumInfo(image_info,image);
1255 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1256 image=DestroyImage(image);
1289 static MagickBooleanType StreamImagePixels(
const StreamInfo *stream_info,
1312 assert(stream_info->signature == MagickCoreSignature);
1313 assert(image != (
Image *) NULL);
1314 assert(image->signature == MagickCoreSignature);
1315 if (IsEventLogging() != MagickFalse)
1316 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1317 length=strlen(stream_info->map);
1318 quantum_map=(QuantumType *) AcquireQuantumMemory(length,
sizeof(*quantum_map));
1319 if (quantum_map == (QuantumType *) NULL)
1321 (void) ThrowMagickException(exception,GetMagickModule(),
1322 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1323 return(MagickFalse);
1325 (void) memset(quantum_map,0,length*
sizeof(*quantum_map));
1326 for (i=0; i < (ssize_t) length; i++)
1328 switch (stream_info->map[i])
1333 quantum_map[i]=AlphaQuantum;
1339 quantum_map[i]=BlueQuantum;
1345 quantum_map[i]=CyanQuantum;
1346 if (image->colorspace == CMYKColorspace)
1348 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1349 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1350 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1351 return(MagickFalse);
1356 quantum_map[i]=GreenQuantum;
1362 quantum_map[i]=IndexQuantum;
1368 quantum_map[i]=BlackQuantum;
1369 if (image->colorspace == CMYKColorspace)
1371 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1372 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1373 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1374 return(MagickFalse);
1379 quantum_map[i]=MagentaQuantum;
1380 if (image->colorspace == CMYKColorspace)
1382 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1383 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1384 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1385 return(MagickFalse);
1390 quantum_map[i]=OpacityQuantum;
1396 quantum_map[i]=UndefinedQuantum;
1402 quantum_map[i]=RedQuantum;
1408 quantum_map[i]=YellowQuantum;
1409 if (image->colorspace == CMYKColorspace)
1411 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1412 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1413 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1414 return(MagickFalse);
1418 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1419 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1420 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
1421 return(MagickFalse);
1425 quantum_info=stream_info->quantum_info;
1426 switch (stream_info->storage_type)
1433 q=(
unsigned char *) stream_info->pixels;
1434 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1436 p=GetAuthenticPixelQueue(image);
1439 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1441 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1442 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1443 *q++=ScaleQuantumToChar(GetPixelRed(p));
1448 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1450 p=GetAuthenticPixelQueue(image);
1453 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1455 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1456 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1457 *q++=ScaleQuantumToChar(GetPixelRed(p));
1458 *q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(p)));
1463 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1465 p=GetAuthenticPixelQueue(image);
1468 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1470 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1471 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1472 *q++=ScaleQuantumToChar(GetPixelRed(p));
1473 *q++=ScaleQuantumToChar((Quantum) 0);
1478 if (LocaleCompare(stream_info->map,
"I") == 0)
1480 p=GetAuthenticPixelQueue(image);
1483 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1485 *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1490 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1492 p=GetAuthenticPixelQueue(image);
1495 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1497 *q++=ScaleQuantumToChar(GetPixelRed(p));
1498 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1499 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1504 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1506 p=GetAuthenticPixelQueue(image);
1509 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1511 *q++=ScaleQuantumToChar(GetPixelRed(p));
1512 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1513 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1514 *q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(p)));
1519 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1521 p=GetAuthenticPixelQueue(image);
1524 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1526 *q++=ScaleQuantumToChar(GetPixelRed(p));
1527 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1528 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1529 *q++=ScaleQuantumToChar((Quantum) 0);
1534 p=GetAuthenticPixelQueue(image);
1537 indexes=GetVirtualIndexQueue(image);
1538 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1540 for (i=0; i < (ssize_t) length; i++)
1543 switch (quantum_map[i])
1548 *q=ScaleQuantumToChar(GetPixelRed(p));
1552 case MagentaQuantum:
1554 *q=ScaleQuantumToChar(GetPixelGreen(p));
1560 *q=ScaleQuantumToChar(GetPixelBlue(p));
1565 *q=ScaleQuantumToChar(GetPixelAlpha(p));
1568 case OpacityQuantum:
1570 *q=ScaleQuantumToChar(GetPixelOpacity(p));
1575 if (image->colorspace == CMYKColorspace)
1576 *q=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1581 *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1598 q=(
double *) stream_info->pixels;
1599 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1601 p=GetAuthenticPixelQueue(image);
1604 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1606 *q++=(double) ((QuantumScale*GetPixelBlue(p))*
1607 quantum_info->scale+quantum_info->minimum);
1608 *q++=(double) ((QuantumScale*GetPixelGreen(p))*
1609 quantum_info->scale+quantum_info->minimum);
1610 *q++=(double) ((QuantumScale*GetPixelRed(p))*
1611 quantum_info->scale+quantum_info->minimum);
1616 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1618 p=GetAuthenticPixelQueue(image);
1621 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1623 *q++=(double) ((QuantumScale*GetPixelBlue(p))*
1624 quantum_info->scale+quantum_info->minimum);
1625 *q++=(double) ((QuantumScale*GetPixelGreen(p))*
1626 quantum_info->scale+quantum_info->minimum);
1627 *q++=(double) ((QuantumScale*GetPixelRed(p))*
1628 quantum_info->scale+quantum_info->minimum);
1629 *q++=(double) ((QuantumScale*GetPixelAlpha(p))*
1630 quantum_info->scale+quantum_info->minimum);
1635 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1637 p=GetAuthenticPixelQueue(image);
1640 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1642 *q++=(double) ((QuantumScale*GetPixelBlue(p))*
1643 quantum_info->scale+quantum_info->minimum);
1644 *q++=(double) ((QuantumScale*GetPixelGreen(p))*
1645 quantum_info->scale+quantum_info->minimum);
1646 *q++=(double) ((QuantumScale*GetPixelRed(p))*
1647 quantum_info->scale+quantum_info->minimum);
1653 if (LocaleCompare(stream_info->map,
"I") == 0)
1655 p=GetAuthenticPixelQueue(image);
1658 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1660 *q++=(double) ((QuantumScale*GetPixelIntensity(image,p))*
1661 quantum_info->scale+quantum_info->minimum);
1666 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1668 p=GetAuthenticPixelQueue(image);
1671 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1673 *q++=(double) ((QuantumScale*GetPixelRed(p))*
1674 quantum_info->scale+quantum_info->minimum);
1675 *q++=(double) ((QuantumScale*GetPixelGreen(p))*
1676 quantum_info->scale+quantum_info->minimum);
1677 *q++=(double) ((QuantumScale*GetPixelBlue(p))*
1678 quantum_info->scale+quantum_info->minimum);
1683 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1685 p=GetAuthenticPixelQueue(image);
1688 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1690 *q++=(double) ((QuantumScale*GetPixelRed(p))*
1691 quantum_info->scale+quantum_info->minimum);
1692 *q++=(double) ((QuantumScale*GetPixelGreen(p))*
1693 quantum_info->scale+quantum_info->minimum);
1694 *q++=(double) ((QuantumScale*GetPixelBlue(p))*
1695 quantum_info->scale+quantum_info->minimum);
1696 *q++=(double) ((QuantumScale*GetPixelAlpha(p))*
1697 quantum_info->scale+quantum_info->minimum);
1702 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1704 p=GetAuthenticPixelQueue(image);
1707 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1709 *q++=(double) ((QuantumScale*GetPixelRed(p))*
1710 quantum_info->scale+quantum_info->minimum);
1711 *q++=(double) ((QuantumScale*GetPixelGreen(p))*
1712 quantum_info->scale+quantum_info->minimum);
1713 *q++=(double) ((QuantumScale*GetPixelBlue(p))*
1714 quantum_info->scale+quantum_info->minimum);
1720 p=GetAuthenticPixelQueue(image);
1723 indexes=GetVirtualIndexQueue(image);
1724 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1726 for (i=0; i < (ssize_t) length; i++)
1729 switch (quantum_map[i])
1734 *q=(double) ((QuantumScale*GetPixelRed(p))*
1735 quantum_info->scale+quantum_info->minimum);
1739 case MagentaQuantum:
1741 *q=(double) ((QuantumScale*GetPixelGreen(p))*
1742 quantum_info->scale+quantum_info->minimum);
1748 *q=(double) ((QuantumScale*GetPixelBlue(p))*
1749 quantum_info->scale+quantum_info->minimum);
1754 *q=(double) ((QuantumScale*GetPixelAlpha(p))*
1755 quantum_info->scale+quantum_info->minimum);
1758 case OpacityQuantum:
1760 *q=(double) ((QuantumScale*GetPixelOpacity(p))*
1761 quantum_info->scale+quantum_info->minimum);
1766 if (image->colorspace == CMYKColorspace)
1767 *q=(double) ((QuantumScale*GetPixelIndex(indexes+x))*
1768 quantum_info->scale+quantum_info->minimum);
1773 *q=(double) ((QuantumScale*GetPixelIntensity(image,p))*
1774 quantum_info->scale+quantum_info->minimum);
1791 q=(
float *) stream_info->pixels;
1792 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1794 p=GetAuthenticPixelQueue(image);
1797 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1799 *q++=(float) ((QuantumScale*GetPixelBlue(p))*
1800 quantum_info->scale+quantum_info->minimum);
1801 *q++=(float) ((QuantumScale*GetPixelGreen(p))*
1802 quantum_info->scale+quantum_info->minimum);
1803 *q++=(float) ((QuantumScale*GetPixelRed(p))*
1804 quantum_info->scale+quantum_info->minimum);
1809 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1811 p=GetAuthenticPixelQueue(image);
1814 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1816 *q++=(float) ((QuantumScale*GetPixelBlue(p))*
1817 quantum_info->scale+quantum_info->minimum);
1818 *q++=(float) ((QuantumScale*GetPixelGreen(p))*
1819 quantum_info->scale+quantum_info->minimum);
1820 *q++=(float) ((QuantumScale*GetPixelRed(p))*
1821 quantum_info->scale+quantum_info->minimum);
1822 *q++=(float) ((QuantumScale*(Quantum) (GetPixelAlpha(p)))*
1823 quantum_info->scale+quantum_info->minimum);
1828 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1830 p=GetAuthenticPixelQueue(image);
1833 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1835 *q++=(float) ((QuantumScale*GetPixelBlue(p))*
1836 quantum_info->scale+quantum_info->minimum);
1837 *q++=(float) ((QuantumScale*GetPixelGreen(p))*
1838 quantum_info->scale+quantum_info->minimum);
1839 *q++=(float) ((QuantumScale*GetPixelRed(p))*
1840 quantum_info->scale+quantum_info->minimum);
1846 if (LocaleCompare(stream_info->map,
"I") == 0)
1848 p=GetAuthenticPixelQueue(image);
1851 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1853 *q++=(float) ((QuantumScale*GetPixelIntensity(image,p))*
1854 quantum_info->scale+quantum_info->minimum);
1859 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1861 p=GetAuthenticPixelQueue(image);
1864 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1866 *q++=(float) ((QuantumScale*GetPixelRed(p))*
1867 quantum_info->scale+quantum_info->minimum);
1868 *q++=(float) ((QuantumScale*GetPixelGreen(p))*
1869 quantum_info->scale+quantum_info->minimum);
1870 *q++=(float) ((QuantumScale*GetPixelBlue(p))*
1871 quantum_info->scale+quantum_info->minimum);
1876 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1878 p=GetAuthenticPixelQueue(image);
1881 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1883 *q++=(float) ((QuantumScale*GetPixelRed(p))*
1884 quantum_info->scale+quantum_info->minimum);
1885 *q++=(float) ((QuantumScale*GetPixelGreen(p))*
1886 quantum_info->scale+quantum_info->minimum);
1887 *q++=(float) ((QuantumScale*GetPixelBlue(p))*
1888 quantum_info->scale+quantum_info->minimum);
1889 *q++=(float) ((QuantumScale*GetPixelAlpha(p))*
1890 quantum_info->scale+quantum_info->minimum);
1895 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1897 p=GetAuthenticPixelQueue(image);
1900 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1902 *q++=(float) ((QuantumScale*GetPixelRed(p))*
1903 quantum_info->scale+quantum_info->minimum);
1904 *q++=(float) ((QuantumScale*GetPixelGreen(p))*
1905 quantum_info->scale+quantum_info->minimum);
1906 *q++=(float) ((QuantumScale*GetPixelBlue(p))*
1907 quantum_info->scale+quantum_info->minimum);
1913 p=GetAuthenticPixelQueue(image);
1916 indexes=GetVirtualIndexQueue(image);
1917 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1919 for (i=0; i < (ssize_t) length; i++)
1922 switch (quantum_map[i])
1927 *q=(float) ((QuantumScale*GetPixelRed(p))*
1928 quantum_info->scale+quantum_info->minimum);
1932 case MagentaQuantum:
1934 *q=(float) ((QuantumScale*GetPixelGreen(p))*
1935 quantum_info->scale+quantum_info->minimum);
1941 *q=(float) ((QuantumScale*GetPixelBlue(p))*
1942 quantum_info->scale+quantum_info->minimum);
1947 *q=(float) ((QuantumScale*GetPixelAlpha(p))*
1948 quantum_info->scale+quantum_info->minimum);
1951 case OpacityQuantum:
1953 *q=(float) ((QuantumScale*GetPixelOpacity(p))*
1954 quantum_info->scale+quantum_info->minimum);
1959 if (image->colorspace == CMYKColorspace)
1960 *q=(float) ((QuantumScale*GetPixelIndex(indexes+x))*
1961 quantum_info->scale+quantum_info->minimum);
1966 *q=(float) ((QuantumScale*GetPixelIntensity(image,p))*
1967 quantum_info->scale+quantum_info->minimum);
1984 q=(
unsigned int *) stream_info->pixels;
1985 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1987 p=GetAuthenticPixelQueue(image);
1990 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1992 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
1993 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
1994 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
1999 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2001 p=GetAuthenticPixelQueue(image);
2004 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2006 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2007 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2008 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2009 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelAlpha(p));
2014 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2016 p=GetAuthenticPixelQueue(image);
2019 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2021 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2022 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2023 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2029 if (LocaleCompare(stream_info->map,
"I") == 0)
2031 p=GetAuthenticPixelQueue(image);
2034 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2036 *q++=(
unsigned int) ScaleQuantumToLong(ClampToQuantum(
2037 GetPixelIntensity(image,p)));
2042 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2044 p=GetAuthenticPixelQueue(image);
2047 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2049 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2050 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2051 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2056 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2058 p=GetAuthenticPixelQueue(image);
2061 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2063 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2064 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2065 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2066 *q++=(
unsigned int) ScaleQuantumToLong((Quantum)
2067 (GetPixelAlpha(p)));
2072 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2074 p=GetAuthenticPixelQueue(image);
2077 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2079 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2080 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2081 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2087 p=GetAuthenticPixelQueue(image);
2090 indexes=GetVirtualIndexQueue(image);
2091 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2093 for (i=0; i < (ssize_t) length; i++)
2096 switch (quantum_map[i])
2101 *q=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2105 case MagentaQuantum:
2107 *q=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2113 *q=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2118 *q=(
unsigned int) ScaleQuantumToLong(GetPixelAlpha(p));
2121 case OpacityQuantum:
2123 *q=(
unsigned int) ScaleQuantumToLong(GetPixelOpacity(p));
2128 if (image->colorspace == CMYKColorspace)
2129 *q=(
unsigned int) ScaleQuantumToLong(GetPixelIndex(
2135 *q=(
unsigned int) ScaleQuantumToLong(ClampToQuantum(
2136 GetPixelIntensity(image,p)));
2153 q=(
size_t *) stream_info->pixels;
2154 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2156 p=GetAuthenticPixelQueue(image);
2159 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2161 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2162 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2163 *q++=ScaleQuantumToLong(GetPixelRed(p));
2168 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2170 p=GetAuthenticPixelQueue(image);
2173 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2175 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2176 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2177 *q++=ScaleQuantumToLong(GetPixelRed(p));
2178 *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p)));
2183 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2185 p=GetAuthenticPixelQueue(image);
2188 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2190 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2191 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2192 *q++=ScaleQuantumToLong(GetPixelRed(p));
2198 if (LocaleCompare(stream_info->map,
"I") == 0)
2200 p=GetAuthenticPixelQueue(image);
2203 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2205 *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2210 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2212 p=GetAuthenticPixelQueue(image);
2215 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2217 *q++=ScaleQuantumToLong(GetPixelRed(p));
2218 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2219 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2224 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2226 p=GetAuthenticPixelQueue(image);
2229 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2231 *q++=ScaleQuantumToLong(GetPixelRed(p));
2232 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2233 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2234 *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p)));
2239 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2241 p=GetAuthenticPixelQueue(image);
2244 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2246 *q++=ScaleQuantumToLong(GetPixelRed(p));
2247 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2248 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2254 p=GetAuthenticPixelQueue(image);
2257 indexes=GetVirtualIndexQueue(image);
2258 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2260 for (i=0; i < (ssize_t) length; i++)
2263 switch (quantum_map[i])
2268 *q=ScaleQuantumToLong(GetPixelRed(p));
2272 case MagentaQuantum:
2274 *q=ScaleQuantumToLong(GetPixelGreen(p));
2280 *q=ScaleQuantumToLong(GetPixelBlue(p));
2285 *q=ScaleQuantumToLong(GetPixelAlpha(p));
2288 case OpacityQuantum:
2290 *q=ScaleQuantumToLong(GetPixelOpacity(p));
2295 if (image->colorspace == CMYKColorspace)
2296 *q=ScaleQuantumToLong(GetPixelIndex(indexes+x));
2301 *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2318 q=(Quantum *) stream_info->pixels;
2319 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2321 p=GetAuthenticPixelQueue(image);
2324 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2326 *q++=GetPixelBlue(p);
2327 *q++=GetPixelGreen(p);
2328 *q++=GetPixelRed(p);
2333 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2335 p=GetAuthenticPixelQueue(image);
2338 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2340 *q++=GetPixelBlue(p);
2341 *q++=GetPixelGreen(p);
2342 *q++=GetPixelRed(p);
2343 *q++=(Quantum) (GetPixelAlpha(p));
2348 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2350 p=GetAuthenticPixelQueue(image);
2353 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2355 *q++=GetPixelBlue(p);
2356 *q++=GetPixelGreen(p);
2357 *q++=GetPixelRed(p);
2363 if (LocaleCompare(stream_info->map,
"I") == 0)
2365 p=GetAuthenticPixelQueue(image);
2368 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2370 *q++=ClampToQuantum(GetPixelIntensity(image,p));
2375 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2377 p=GetAuthenticPixelQueue(image);
2380 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2382 *q++=GetPixelRed(p);
2383 *q++=GetPixelGreen(p);
2384 *q++=GetPixelBlue(p);
2389 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2391 p=GetAuthenticPixelQueue(image);
2394 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2396 *q++=GetPixelRed(p);
2397 *q++=GetPixelGreen(p);
2398 *q++=GetPixelBlue(p);
2399 *q++=(Quantum) (GetPixelAlpha(p));
2404 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2406 p=GetAuthenticPixelQueue(image);
2409 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2411 *q++=GetPixelRed(p);
2412 *q++=GetPixelGreen(p);
2413 *q++=GetPixelBlue(p);
2419 p=GetAuthenticPixelQueue(image);
2422 indexes=GetVirtualIndexQueue(image);
2423 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2425 for (i=0; i < (ssize_t) length; i++)
2428 switch (quantum_map[i])
2437 case MagentaQuantum:
2439 *q=GetPixelGreen(p);
2450 *q=GetPixelAlpha(p);
2453 case OpacityQuantum:
2455 *q=GetPixelOpacity(p);
2460 if (image->colorspace == CMYKColorspace)
2461 *q=GetPixelIndex(indexes+x);
2466 *q=ClampToQuantum(GetPixelIntensity(image,p));
2483 q=(
unsigned short *) stream_info->pixels;
2484 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2486 p=GetAuthenticPixelQueue(image);
2489 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2491 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2492 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2493 *q++=ScaleQuantumToShort(GetPixelRed(p));
2498 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2500 p=GetAuthenticPixelQueue(image);
2503 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2505 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2506 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2507 *q++=ScaleQuantumToShort(GetPixelRed(p));
2508 *q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(p)));
2513 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2515 p=GetAuthenticPixelQueue(image);
2518 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2520 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2521 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2522 *q++=ScaleQuantumToShort(GetPixelRed(p));
2528 if (LocaleCompare(stream_info->map,
"I") == 0)
2530 p=GetAuthenticPixelQueue(image);
2533 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2535 *q++=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,
2541 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2543 p=GetAuthenticPixelQueue(image);
2546 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2548 *q++=ScaleQuantumToShort(GetPixelRed(p));
2549 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2550 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2555 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2557 p=GetAuthenticPixelQueue(image);
2560 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2562 *q++=ScaleQuantumToShort(GetPixelRed(p));
2563 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2564 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2565 *q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(p)));
2570 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2572 p=GetAuthenticPixelQueue(image);
2575 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2577 *q++=ScaleQuantumToShort(GetPixelRed(p));
2578 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2579 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2585 p=GetAuthenticPixelQueue(image);
2588 indexes=GetVirtualIndexQueue(image);
2589 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2591 for (i=0; i < (ssize_t) length; i++)
2594 switch (quantum_map[i])
2599 *q=ScaleQuantumToShort(GetPixelRed(p));
2603 case MagentaQuantum:
2605 *q=ScaleQuantumToShort(GetPixelGreen(p));
2611 *q=ScaleQuantumToShort(GetPixelBlue(p));
2616 *q=ScaleQuantumToShort(GetPixelAlpha(p));
2619 case OpacityQuantum:
2621 *q=ScaleQuantumToShort(GetPixelOpacity(p));
2626 if (image->colorspace == CMYKColorspace)
2627 *q=ScaleQuantumToShort(GetPixelIndex(indexes+x));
2632 *q=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,
2647 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2648 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2649 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
2653 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2683 static MagickBooleanType SyncAuthenticPixelsStream(
Image *image,
2695 assert(image != (
Image *) NULL);
2696 assert(image->signature == MagickCoreSignature);
2697 if (IsEventLogging() != MagickFalse)
2698 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2700 assert(cache_info->signature == MagickCoreSignature);
2701 stream_handler=GetBlobStreamHandler(image);
2702 if (stream_handler == (StreamHandler) NULL)
2704 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
2705 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
2706 return(MagickFalse);
2708 length=stream_handler(image,cache_info->pixels,(
size_t) cache_info->columns);
2709 return(length == cache_info->columns ? MagickTrue : MagickFalse);
2738 MagickExport MagickBooleanType WriteStream(
const ImageInfo *image_info,
2739 Image *image,StreamHandler stream)
2747 assert(image_info != (
ImageInfo *) NULL);
2748 assert(image_info->signature == MagickCoreSignature);
2749 assert(image != (
Image *) NULL);
2750 assert(image->signature == MagickCoreSignature);
2751 if (IsEventLogging() != MagickFalse)
2752 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2753 image_info->filename);
2754 write_info=CloneImageInfo(image_info);
2755 *write_info->magick=
'\0';
2756 write_info->stream=stream;
2757 status=WriteImage(write_info,image);
2758 write_info=DestroyImageInfo(write_info);