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,
118static 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;
195static 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;
214static 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);
316static 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);
445static 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);
494static 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);
533MagickExport
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);
603static 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);
653static 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);
774MagickExport 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);
817static 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))
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);
957MagickExport
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);
1020MagickPrivate
void ResetStreamAnonymousMemory(
void)
1049MagickExport
void SetStreamInfoClientData(
StreamInfo *stream_info,
1050 const void *client_data)
1053 assert(stream_info->signature == MagickCoreSignature);
1054 stream_info->client_data=client_data;
1081MagickExport
void SetStreamInfoMap(
StreamInfo *stream_info,
const char *map)
1084 assert(stream_info->signature == MagickCoreSignature);
1085 (void) CloneString(&stream_info->map,map);
1113MagickExport
void SetStreamInfoStorageType(
StreamInfo *stream_info,
1114 const StorageType storage_type)
1117 assert(stream_info->signature == MagickCoreSignature);
1118 stream_info->storage_type=storage_type;
1150#if defined(__cplusplus) || defined(c_plusplus)
1154static size_t WriteStreamImage(
const Image *image,
const void *pixels,
1155 const size_t columns)
1174 stream_info=(
StreamInfo *) image->client_data;
1175 switch (stream_info->storage_type)
1177 default: packet_size=
sizeof(char);
break;
1178 case CharPixel: packet_size=
sizeof(char);
break;
1179 case DoublePixel: packet_size=
sizeof(double);
break;
1180 case FloatPixel: packet_size=
sizeof(float);
break;
1181 case IntegerPixel: packet_size=
sizeof(int);
break;
1182 case LongPixel: packet_size=
sizeof(ssize_t);
break;
1183 case QuantumPixel: packet_size=
sizeof(Quantum);
break;
1184 case ShortPixel: packet_size=
sizeof(
unsigned short);
break;
1187 assert(cache_info->signature == MagickCoreSignature);
1188 packet_size*=strlen(stream_info->map);
1189 length=packet_size*cache_info->columns*cache_info->rows;
1190 if (image != stream_info->image)
1198 (void) RelinquishAlignedMemory(stream_info->pixels);
1199 stream_info->pixels=(
unsigned char *) MagickAssumeAligned(
1200 AcquireAlignedMemory(1,length));
1201 if (stream_info->pixels == (
unsigned char *) NULL)
1203 (void) memset(stream_info->pixels,0,length);
1204 stream_info->image=image;
1205 write_info=CloneImageInfo(stream_info->image_info);
1206 (void) SetImageInfo(write_info,1,stream_info->exception);
1207 if (write_info->extract != (
char *) NULL)
1208 (
void) ParseAbsoluteGeometry(write_info->extract,
1209 &stream_info->extract_info);
1211 write_info=DestroyImageInfo(write_info);
1213 extract_info=stream_info->extract_info;
1214 if ((extract_info.width == 0) || (extract_info.height == 0))
1219 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1220 count=WriteBlob(stream_info->stream,length,stream_info->pixels);
1222 return(count == 0 ? 0 : columns);
1224 if ((stream_info->y < extract_info.y) ||
1225 (stream_info->y >= (ssize_t) (extract_info.y+extract_info.height)))
1233 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1234 length=packet_size*extract_info.width;
1235 count=WriteBlob(stream_info->stream,length,stream_info->pixels+packet_size*
1238 return(count == 0 ? 0 : columns);
1241#if defined(__cplusplus) || defined(c_plusplus)
1254 assert(image_info != (
const ImageInfo *) NULL);
1255 assert(image_info->signature == MagickCoreSignature);
1257 assert(stream_info->signature == MagickCoreSignature);
1259 if (IsEventLogging() != MagickFalse)
1260 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1261 image_info->filename);
1262 read_info=CloneImageInfo(image_info);
1263 stream_info->image_info=image_info;
1264 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1265 stream_info->quantum_info=AcquireQuantumInfo(image_info,(
Image *) NULL);
1266 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1268 read_info=DestroyImageInfo(read_info);
1269 return((
Image *) NULL);
1271 stream_info->exception=exception;
1272 read_info->client_data=(
void *) stream_info;
1273 image=ReadStream(read_info,&WriteStreamImage,exception);
1274 read_info=DestroyImageInfo(read_info);
1275 stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
1276 stream_info->quantum_info=AcquireQuantumInfo(image_info,image);
1277 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1278 image=DestroyImage(image);
1311static MagickBooleanType StreamImagePixels(
const StreamInfo *stream_info,
1334 assert(stream_info->signature == MagickCoreSignature);
1335 assert(image != (
Image *) NULL);
1336 assert(image->signature == MagickCoreSignature);
1337 if (IsEventLogging() != MagickFalse)
1338 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1339 length=strlen(stream_info->map);
1340 quantum_map=(QuantumType *) AcquireQuantumMemory(length,
sizeof(*quantum_map));
1341 if (quantum_map == (QuantumType *) NULL)
1343 (void) ThrowMagickException(exception,GetMagickModule(),
1344 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1345 return(MagickFalse);
1347 (void) memset(quantum_map,0,length*
sizeof(*quantum_map));
1348 for (i=0; i < (ssize_t) length; i++)
1350 switch (stream_info->map[i])
1355 quantum_map[i]=AlphaQuantum;
1361 quantum_map[i]=BlueQuantum;
1367 quantum_map[i]=CyanQuantum;
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]=GreenQuantum;
1384 quantum_map[i]=IndexQuantum;
1390 quantum_map[i]=BlackQuantum;
1391 if (image->colorspace == CMYKColorspace)
1393 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1394 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1395 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1396 return(MagickFalse);
1401 quantum_map[i]=MagentaQuantum;
1402 if (image->colorspace == CMYKColorspace)
1404 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1405 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1406 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1407 return(MagickFalse);
1412 quantum_map[i]=OpacityQuantum;
1418 quantum_map[i]=UndefinedQuantum;
1424 quantum_map[i]=RedQuantum;
1430 quantum_map[i]=YellowQuantum;
1431 if (image->colorspace == CMYKColorspace)
1433 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1434 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1435 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1436 return(MagickFalse);
1440 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1441 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1442 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
1443 return(MagickFalse);
1447 quantum_info=stream_info->quantum_info;
1448 switch (stream_info->storage_type)
1455 q=(
unsigned char *) stream_info->pixels;
1456 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1458 p=GetAuthenticPixelQueue(image);
1461 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1463 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1464 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1465 *q++=ScaleQuantumToChar(GetPixelRed(p));
1470 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1472 p=GetAuthenticPixelQueue(image);
1475 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1477 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1478 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1479 *q++=ScaleQuantumToChar(GetPixelRed(p));
1480 *q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(p)));
1485 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1487 p=GetAuthenticPixelQueue(image);
1490 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1492 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1493 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1494 *q++=ScaleQuantumToChar(GetPixelRed(p));
1495 *q++=ScaleQuantumToChar((Quantum) 0);
1500 if (LocaleCompare(stream_info->map,
"I") == 0)
1502 p=GetAuthenticPixelQueue(image);
1505 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1507 *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1512 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1514 p=GetAuthenticPixelQueue(image);
1517 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1519 *q++=ScaleQuantumToChar(GetPixelRed(p));
1520 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1521 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1526 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1528 p=GetAuthenticPixelQueue(image);
1531 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1533 *q++=ScaleQuantumToChar(GetPixelRed(p));
1534 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1535 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1536 *q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(p)));
1541 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1543 p=GetAuthenticPixelQueue(image);
1546 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1548 *q++=ScaleQuantumToChar(GetPixelRed(p));
1549 *q++=ScaleQuantumToChar(GetPixelGreen(p));
1550 *q++=ScaleQuantumToChar(GetPixelBlue(p));
1551 *q++=ScaleQuantumToChar((Quantum) 0);
1556 p=GetAuthenticPixelQueue(image);
1559 indexes=GetVirtualIndexQueue(image);
1560 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1562 for (i=0; i < (ssize_t) length; i++)
1565 switch (quantum_map[i])
1570 *q=ScaleQuantumToChar(GetPixelRed(p));
1574 case MagentaQuantum:
1576 *q=ScaleQuantumToChar(GetPixelGreen(p));
1582 *q=ScaleQuantumToChar(GetPixelBlue(p));
1587 *q=ScaleQuantumToChar(GetPixelAlpha(p));
1590 case OpacityQuantum:
1592 *q=ScaleQuantumToChar(GetPixelOpacity(p));
1597 if (image->colorspace == CMYKColorspace)
1598 *q=ScaleQuantumToChar(GetPixelIndex(indexes+x));
1603 *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1620 q=(
double *) stream_info->pixels;
1621 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1623 p=GetAuthenticPixelQueue(image);
1626 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1628 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1629 quantum_info->scale+quantum_info->minimum);
1630 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1631 quantum_info->scale+quantum_info->minimum);
1632 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1633 quantum_info->scale+quantum_info->minimum);
1638 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1640 p=GetAuthenticPixelQueue(image);
1643 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1645 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1646 quantum_info->scale+quantum_info->minimum);
1647 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1648 quantum_info->scale+quantum_info->minimum);
1649 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1650 quantum_info->scale+quantum_info->minimum);
1651 *q++=(double) ((QuantumScale*(
double) GetPixelAlpha(p))*
1652 quantum_info->scale+quantum_info->minimum);
1657 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1659 p=GetAuthenticPixelQueue(image);
1662 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1664 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1665 quantum_info->scale+quantum_info->minimum);
1666 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1667 quantum_info->scale+quantum_info->minimum);
1668 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1669 quantum_info->scale+quantum_info->minimum);
1675 if (LocaleCompare(stream_info->map,
"I") == 0)
1677 p=GetAuthenticPixelQueue(image);
1680 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1682 *q++=(double) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1683 quantum_info->scale+quantum_info->minimum);
1688 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1690 p=GetAuthenticPixelQueue(image);
1693 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1695 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1696 quantum_info->scale+quantum_info->minimum);
1697 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1698 quantum_info->scale+quantum_info->minimum);
1699 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1700 quantum_info->scale+quantum_info->minimum);
1705 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1707 p=GetAuthenticPixelQueue(image);
1710 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1712 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1713 quantum_info->scale+quantum_info->minimum);
1714 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1715 quantum_info->scale+quantum_info->minimum);
1716 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1717 quantum_info->scale+quantum_info->minimum);
1718 *q++=(double) ((QuantumScale*(
double) GetPixelAlpha(p))*
1719 quantum_info->scale+quantum_info->minimum);
1724 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1726 p=GetAuthenticPixelQueue(image);
1729 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1731 *q++=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1732 quantum_info->scale+quantum_info->minimum);
1733 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1734 quantum_info->scale+quantum_info->minimum);
1735 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1736 quantum_info->scale+quantum_info->minimum);
1742 p=GetAuthenticPixelQueue(image);
1745 indexes=GetVirtualIndexQueue(image);
1746 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1748 for (i=0; i < (ssize_t) length; i++)
1751 switch (quantum_map[i])
1756 *q=(double) ((QuantumScale*(
double) GetPixelRed(p))*
1757 quantum_info->scale+quantum_info->minimum);
1761 case MagentaQuantum:
1763 *q=(double) ((QuantumScale*(
double) GetPixelGreen(p))*
1764 quantum_info->scale+quantum_info->minimum);
1770 *q=(double) ((QuantumScale*(
double) GetPixelBlue(p))*
1771 quantum_info->scale+quantum_info->minimum);
1776 *q=(double) ((QuantumScale*(
double) GetPixelAlpha(p))*
1777 quantum_info->scale+quantum_info->minimum);
1780 case OpacityQuantum:
1782 *q=(double) ((QuantumScale*(
double) GetPixelOpacity(p))*
1783 quantum_info->scale+quantum_info->minimum);
1788 if (image->colorspace == CMYKColorspace)
1789 *q=(double) ((QuantumScale*(
double) GetPixelIndex(indexes+x))*
1790 quantum_info->scale+quantum_info->minimum);
1795 *q=(double) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1796 quantum_info->scale+quantum_info->minimum);
1813 q=(
float *) stream_info->pixels;
1814 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1816 p=GetAuthenticPixelQueue(image);
1819 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1821 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1822 quantum_info->scale+quantum_info->minimum);
1823 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1824 quantum_info->scale+quantum_info->minimum);
1825 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1826 quantum_info->scale+quantum_info->minimum);
1831 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1833 p=GetAuthenticPixelQueue(image);
1836 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1838 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1839 quantum_info->scale+quantum_info->minimum);
1840 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1841 quantum_info->scale+quantum_info->minimum);
1842 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1843 quantum_info->scale+quantum_info->minimum);
1844 *q++=(float) ((QuantumScale*(
double) GetPixelAlpha(p))*
1845 quantum_info->scale+quantum_info->minimum);
1850 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1852 p=GetAuthenticPixelQueue(image);
1855 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1857 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1858 quantum_info->scale+quantum_info->minimum);
1859 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1860 quantum_info->scale+quantum_info->minimum);
1861 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1862 quantum_info->scale+quantum_info->minimum);
1868 if (LocaleCompare(stream_info->map,
"I") == 0)
1870 p=GetAuthenticPixelQueue(image);
1873 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1875 *q++=(float) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1876 quantum_info->scale+quantum_info->minimum);
1881 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1883 p=GetAuthenticPixelQueue(image);
1886 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1888 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1889 quantum_info->scale+quantum_info->minimum);
1890 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1891 quantum_info->scale+quantum_info->minimum);
1892 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1893 quantum_info->scale+quantum_info->minimum);
1898 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1900 p=GetAuthenticPixelQueue(image);
1903 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1905 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1906 quantum_info->scale+quantum_info->minimum);
1907 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1908 quantum_info->scale+quantum_info->minimum);
1909 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1910 quantum_info->scale+quantum_info->minimum);
1911 *q++=(float) ((QuantumScale*(
double) GetPixelAlpha(p))*
1912 quantum_info->scale+quantum_info->minimum);
1917 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1919 p=GetAuthenticPixelQueue(image);
1922 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1924 *q++=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1925 quantum_info->scale+quantum_info->minimum);
1926 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1927 quantum_info->scale+quantum_info->minimum);
1928 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1929 quantum_info->scale+quantum_info->minimum);
1935 p=GetAuthenticPixelQueue(image);
1938 indexes=GetVirtualIndexQueue(image);
1939 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1941 for (i=0; i < (ssize_t) length; i++)
1944 switch (quantum_map[i])
1949 *q=(float) ((QuantumScale*(
double) GetPixelRed(p))*
1950 quantum_info->scale+quantum_info->minimum);
1954 case MagentaQuantum:
1956 *q=(float) ((QuantumScale*(
double) GetPixelGreen(p))*
1957 quantum_info->scale+quantum_info->minimum);
1963 *q=(float) ((QuantumScale*(
double) GetPixelBlue(p))*
1964 quantum_info->scale+quantum_info->minimum);
1969 *q=(float) ((QuantumScale*(
double) GetPixelAlpha(p))*
1970 quantum_info->scale+quantum_info->minimum);
1973 case OpacityQuantum:
1975 *q=(float) ((QuantumScale*(
double) GetPixelOpacity(p))*
1976 quantum_info->scale+quantum_info->minimum);
1981 if (image->colorspace == CMYKColorspace)
1982 *q=(float) ((QuantumScale*(
double) GetPixelIndex(indexes+x))*
1983 quantum_info->scale+quantum_info->minimum);
1988 *q=(float) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1989 quantum_info->scale+quantum_info->minimum);
2006 q=(
unsigned int *) stream_info->pixels;
2007 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2009 p=GetAuthenticPixelQueue(image);
2012 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2014 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2015 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2016 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2021 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2023 p=GetAuthenticPixelQueue(image);
2026 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2028 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2029 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2030 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2031 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelAlpha(p));
2036 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2038 p=GetAuthenticPixelQueue(image);
2041 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2043 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2044 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2045 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2051 if (LocaleCompare(stream_info->map,
"I") == 0)
2053 p=GetAuthenticPixelQueue(image);
2056 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2058 *q++=(
unsigned int) ScaleQuantumToLong(ClampToQuantum(
2059 GetPixelIntensity(image,p)));
2064 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2066 p=GetAuthenticPixelQueue(image);
2069 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2071 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2072 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2073 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2078 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2080 p=GetAuthenticPixelQueue(image);
2083 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2085 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2086 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2087 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2088 *q++=(
unsigned int) ScaleQuantumToLong((Quantum)
2089 (GetPixelAlpha(p)));
2094 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2096 p=GetAuthenticPixelQueue(image);
2099 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2101 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2102 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2103 *q++=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2109 p=GetAuthenticPixelQueue(image);
2112 indexes=GetVirtualIndexQueue(image);
2113 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2115 for (i=0; i < (ssize_t) length; i++)
2118 switch (quantum_map[i])
2123 *q=(
unsigned int) ScaleQuantumToLong(GetPixelRed(p));
2127 case MagentaQuantum:
2129 *q=(
unsigned int) ScaleQuantumToLong(GetPixelGreen(p));
2135 *q=(
unsigned int) ScaleQuantumToLong(GetPixelBlue(p));
2140 *q=(
unsigned int) ScaleQuantumToLong(GetPixelAlpha(p));
2143 case OpacityQuantum:
2145 *q=(
unsigned int) ScaleQuantumToLong(GetPixelOpacity(p));
2150 if (image->colorspace == CMYKColorspace)
2151 *q=(
unsigned int) ScaleQuantumToLong(GetPixelIndex(
2157 *q=(
unsigned int) ScaleQuantumToLong(ClampToQuantum(
2158 GetPixelIntensity(image,p)));
2175 q=(
size_t *) stream_info->pixels;
2176 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2178 p=GetAuthenticPixelQueue(image);
2181 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2183 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2184 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2185 *q++=ScaleQuantumToLong(GetPixelRed(p));
2190 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2192 p=GetAuthenticPixelQueue(image);
2195 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2197 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2198 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2199 *q++=ScaleQuantumToLong(GetPixelRed(p));
2200 *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p)));
2205 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2207 p=GetAuthenticPixelQueue(image);
2210 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2212 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2213 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2214 *q++=ScaleQuantumToLong(GetPixelRed(p));
2220 if (LocaleCompare(stream_info->map,
"I") == 0)
2222 p=GetAuthenticPixelQueue(image);
2225 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2227 *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2232 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2234 p=GetAuthenticPixelQueue(image);
2237 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2239 *q++=ScaleQuantumToLong(GetPixelRed(p));
2240 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2241 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2246 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2248 p=GetAuthenticPixelQueue(image);
2251 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2253 *q++=ScaleQuantumToLong(GetPixelRed(p));
2254 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2255 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2256 *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(p)));
2261 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2263 p=GetAuthenticPixelQueue(image);
2266 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2268 *q++=ScaleQuantumToLong(GetPixelRed(p));
2269 *q++=ScaleQuantumToLong(GetPixelGreen(p));
2270 *q++=ScaleQuantumToLong(GetPixelBlue(p));
2276 p=GetAuthenticPixelQueue(image);
2279 indexes=GetVirtualIndexQueue(image);
2280 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2282 for (i=0; i < (ssize_t) length; i++)
2285 switch (quantum_map[i])
2290 *q=ScaleQuantumToLong(GetPixelRed(p));
2294 case MagentaQuantum:
2296 *q=ScaleQuantumToLong(GetPixelGreen(p));
2302 *q=ScaleQuantumToLong(GetPixelBlue(p));
2307 *q=ScaleQuantumToLong(GetPixelAlpha(p));
2310 case OpacityQuantum:
2312 *q=ScaleQuantumToLong(GetPixelOpacity(p));
2317 if (image->colorspace == CMYKColorspace)
2318 *q=ScaleQuantumToLong(GetPixelIndex(indexes+x));
2323 *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2340 q=(Quantum *) stream_info->pixels;
2341 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2343 p=GetAuthenticPixelQueue(image);
2346 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2348 *q++=GetPixelBlue(p);
2349 *q++=GetPixelGreen(p);
2350 *q++=GetPixelRed(p);
2355 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2357 p=GetAuthenticPixelQueue(image);
2360 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2362 *q++=GetPixelBlue(p);
2363 *q++=GetPixelGreen(p);
2364 *q++=GetPixelRed(p);
2365 *q++=(Quantum) (GetPixelAlpha(p));
2370 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2372 p=GetAuthenticPixelQueue(image);
2375 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2377 *q++=GetPixelBlue(p);
2378 *q++=GetPixelGreen(p);
2379 *q++=GetPixelRed(p);
2385 if (LocaleCompare(stream_info->map,
"I") == 0)
2387 p=GetAuthenticPixelQueue(image);
2390 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2392 *q++=ClampToQuantum(GetPixelIntensity(image,p));
2397 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2399 p=GetAuthenticPixelQueue(image);
2402 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2404 *q++=GetPixelRed(p);
2405 *q++=GetPixelGreen(p);
2406 *q++=GetPixelBlue(p);
2411 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2413 p=GetAuthenticPixelQueue(image);
2416 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2418 *q++=GetPixelRed(p);
2419 *q++=GetPixelGreen(p);
2420 *q++=GetPixelBlue(p);
2421 *q++=(Quantum) (GetPixelAlpha(p));
2426 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2428 p=GetAuthenticPixelQueue(image);
2431 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2433 *q++=GetPixelRed(p);
2434 *q++=GetPixelGreen(p);
2435 *q++=GetPixelBlue(p);
2441 p=GetAuthenticPixelQueue(image);
2444 indexes=GetVirtualIndexQueue(image);
2445 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2447 for (i=0; i < (ssize_t) length; i++)
2450 switch (quantum_map[i])
2459 case MagentaQuantum:
2461 *q=GetPixelGreen(p);
2472 *q=GetPixelAlpha(p);
2475 case OpacityQuantum:
2477 *q=GetPixelOpacity(p);
2482 if (image->colorspace == CMYKColorspace)
2483 *q=GetPixelIndex(indexes+x);
2488 *q=ClampToQuantum(GetPixelIntensity(image,p));
2505 q=(
unsigned short *) stream_info->pixels;
2506 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2508 p=GetAuthenticPixelQueue(image);
2511 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2513 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2514 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2515 *q++=ScaleQuantumToShort(GetPixelRed(p));
2520 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2522 p=GetAuthenticPixelQueue(image);
2525 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2527 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2528 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2529 *q++=ScaleQuantumToShort(GetPixelRed(p));
2530 *q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(p)));
2535 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2537 p=GetAuthenticPixelQueue(image);
2540 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2542 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2543 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2544 *q++=ScaleQuantumToShort(GetPixelRed(p));
2550 if (LocaleCompare(stream_info->map,
"I") == 0)
2552 p=GetAuthenticPixelQueue(image);
2555 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2557 *q++=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,
2563 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2565 p=GetAuthenticPixelQueue(image);
2568 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2570 *q++=ScaleQuantumToShort(GetPixelRed(p));
2571 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2572 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2577 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2579 p=GetAuthenticPixelQueue(image);
2582 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2584 *q++=ScaleQuantumToShort(GetPixelRed(p));
2585 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2586 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2587 *q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(p)));
2592 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2594 p=GetAuthenticPixelQueue(image);
2597 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2599 *q++=ScaleQuantumToShort(GetPixelRed(p));
2600 *q++=ScaleQuantumToShort(GetPixelGreen(p));
2601 *q++=ScaleQuantumToShort(GetPixelBlue(p));
2607 p=GetAuthenticPixelQueue(image);
2610 indexes=GetVirtualIndexQueue(image);
2611 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2613 for (i=0; i < (ssize_t) length; i++)
2616 switch (quantum_map[i])
2621 *q=ScaleQuantumToShort(GetPixelRed(p));
2625 case MagentaQuantum:
2627 *q=ScaleQuantumToShort(GetPixelGreen(p));
2633 *q=ScaleQuantumToShort(GetPixelBlue(p));
2638 *q=ScaleQuantumToShort(GetPixelAlpha(p));
2641 case OpacityQuantum:
2643 *q=ScaleQuantumToShort(GetPixelOpacity(p));
2648 if (image->colorspace == CMYKColorspace)
2649 *q=ScaleQuantumToShort(GetPixelIndex(indexes+x));
2654 *q=ScaleQuantumToShort(ClampToQuantum(GetPixelIntensity(image,
2669 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2670 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2671 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
2675 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2705static MagickBooleanType SyncAuthenticPixelsStream(
Image *image,
2717 assert(image != (
Image *) NULL);
2718 assert(image->signature == MagickCoreSignature);
2719 if (IsEventLogging() != MagickFalse)
2720 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2722 assert(cache_info->signature == MagickCoreSignature);
2723 stream_handler=GetBlobStreamHandler(image);
2724 if (stream_handler == (StreamHandler) NULL)
2726 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
2727 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
2728 return(MagickFalse);
2730 length=stream_handler(image,cache_info->pixels,(
size_t) cache_info->columns);
2731 return(length == cache_info->columns ? MagickTrue : MagickFalse);
2760MagickExport MagickBooleanType WriteStream(
const ImageInfo *image_info,
2761 Image *image,StreamHandler stream)
2769 assert(image_info != (
ImageInfo *) NULL);
2770 assert(image_info->signature == MagickCoreSignature);
2771 assert(image != (
Image *) NULL);
2772 assert(image->signature == MagickCoreSignature);
2773 if (IsEventLogging() != MagickFalse)
2774 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2775 image_info->filename);
2776 write_info=CloneImageInfo(image_info);
2777 *write_info->magick=
'\0';
2778 write_info->stream=stream;
2779 status=WriteImage(write_info,image);
2780 write_info=DestroyImageInfo(write_info);