43#include "MagickCore/studio.h"
44#include "MagickCore/blob.h"
45#include "MagickCore/blob-private.h"
46#include "MagickCore/cache.h"
47#include "MagickCore/cache-private.h"
48#include "MagickCore/color-private.h"
49#include "MagickCore/composite-private.h"
50#include "MagickCore/constitute.h"
51#include "MagickCore/exception.h"
52#include "MagickCore/exception-private.h"
53#include "MagickCore/geometry.h"
54#include "MagickCore/memory_.h"
55#include "MagickCore/memory-private.h"
56#include "MagickCore/pixel.h"
57#include "MagickCore/pixel-accessor.h"
58#include "MagickCore/pixel-private.h"
59#include "MagickCore/policy.h"
60#include "MagickCore/quantum.h"
61#include "MagickCore/quantum-private.h"
62#include "MagickCore/semaphore.h"
63#include "MagickCore/stream.h"
64#include "MagickCore/stream-private.h"
65#include "MagickCore/string_.h"
115#if defined(__cplusplus) || defined(c_plusplus)
120 *GetVirtualPixelStream(
const Image *,
const VirtualPixelMethod,
const ssize_t,
121 const ssize_t,
const size_t,
const size_t,ExceptionInfo *);
123static MagickBooleanType
124 StreamImagePixels(
const StreamInfo *,
const Image *,ExceptionInfo *),
125 SyncAuthenticPixelsStream(Image *,ExceptionInfo *);
128 *QueueAuthenticPixelsStream(Image *,
const ssize_t,
const ssize_t,
const size_t,
129 const size_t,ExceptionInfo *);
131#if defined(__cplusplus) || defined(c_plusplus)
160MagickExport StreamInfo *AcquireStreamInfo(
const ImageInfo *image_info,
161 ExceptionInfo *exception)
166 stream_info=(StreamInfo *) AcquireCriticalMemory(
sizeof(*stream_info));
167 (void) memset(stream_info,0,
sizeof(*stream_info));
168 stream_info->pixels=(
unsigned char *) MagickAssumeAligned(
169 AcquireAlignedMemory(1,
sizeof(*stream_info->pixels)));
170 if (stream_info->pixels == (
unsigned char *) NULL)
171 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
172 stream_info->map=ConstantString(
"RGB");
173 stream_info->storage_type=CharPixel;
174 stream_info->stream=AcquireImage(image_info,exception);
175 stream_info->signature=MagickCoreSignature;
202static inline void RelinquishStreamPixels(CacheInfo *cache_info)
204 assert(cache_info != (CacheInfo *) NULL);
205 if (cache_info->pixels != (Quantum *) NULL)
207 if (cache_info->mapped == MagickFalse)
208 cache_info->pixels=(Quantum *) RelinquishAlignedMemory(
212 (void) UnmapBlob(cache_info->pixels,(
size_t) cache_info->length);
213 cache_info->pixels=(Quantum *) NULL;
216 cache_info->mapped=MagickFalse;
217 cache_info->metacontent=(
void *) NULL;
218 cache_info->length=0;
221static void DestroyPixelStream(Image *image)
229 assert(image != (Image *) NULL);
230 assert(image->signature == MagickCoreSignature);
231 if (IsEventLogging() != MagickFalse)
232 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
233 cache_info=(CacheInfo *) image->cache;
234 assert(cache_info->signature == MagickCoreSignature);
236 LockSemaphoreInfo(cache_info->semaphore);
237 cache_info->reference_count--;
238 if (cache_info->reference_count == 0)
240 UnlockSemaphoreInfo(cache_info->semaphore);
241 if (destroy == MagickFalse)
243 RelinquishStreamPixels(cache_info);
244 if (cache_info->nexus_info != (NexusInfo **) NULL)
245 cache_info->nexus_info=DestroyPixelCacheNexus(cache_info->nexus_info,
246 cache_info->number_threads);
248 RelinquishSemaphoreInfo(&cache_info->file_semaphore);
250 RelinquishSemaphoreInfo(&cache_info->semaphore);
251 cache_info=(CacheInfo *) RelinquishAlignedMemory(cache_info);
277MagickExport StreamInfo *DestroyStreamInfo(StreamInfo *stream_info)
279 assert(stream_info != (StreamInfo *) NULL);
280 assert(stream_info->signature == MagickCoreSignature);
281 if (IsEventLogging() != MagickFalse)
282 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
283 if (stream_info->map != (
char *) NULL)
284 stream_info->map=DestroyString(stream_info->map);
285 if (stream_info->pixels != (
unsigned char *) NULL)
286 stream_info->pixels=(
unsigned char *) RelinquishAlignedMemory(
287 stream_info->pixels);
288 if (stream_info->stream != (Image *) NULL)
290 (void) CloseBlob(stream_info->stream);
291 stream_info->stream=DestroyImage(stream_info->stream);
293 if (stream_info->quantum_info != (QuantumInfo *) NULL)
294 stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
295 stream_info->signature=(~MagickCoreSignature);
296 stream_info=(StreamInfo *) RelinquishMagickMemory(stream_info);
324static void *GetAuthenticMetacontentFromStream(
const Image *image)
329 assert(image != (Image *) NULL);
330 assert(image->signature == MagickCoreSignature);
331 if (IsEventLogging() != MagickFalse)
332 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
333 cache_info=(CacheInfo *) image->cache;
334 assert(cache_info->signature == MagickCoreSignature);
335 return(cache_info->metacontent);
370static Quantum *GetAuthenticPixelsStream(Image *image,
const ssize_t x,
371 const ssize_t y,
const size_t columns,
const size_t rows,
372 ExceptionInfo *exception)
377 assert(image != (Image *) NULL);
378 assert(image->signature == MagickCoreSignature);
379 if (IsEventLogging() != MagickFalse)
380 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
381 pixels=QueueAuthenticPixelsStream(image,x,y,columns,rows,exception);
408static Quantum *GetAuthenticPixelsFromStream(
const Image *image)
413 assert(image != (Image *) NULL);
414 assert(image->signature == MagickCoreSignature);
415 if (IsEventLogging() != MagickFalse)
416 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
417 cache_info=(CacheInfo *) image->cache;
418 assert(cache_info->signature == MagickCoreSignature);
419 return(cache_info->pixels);
453static MagickBooleanType GetOneAuthenticPixelFromStream(Image *image,
454 const ssize_t x,
const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
462 assert(image != (Image *) NULL);
463 assert(image->signature == MagickCoreSignature);
464 (void) memset(pixel,0,MaxPixelChannels*
sizeof(*pixel));
465 p=GetAuthenticPixelsStream(image,x,y,1,1,exception);
466 if (p == (Quantum *) NULL)
468 pixel[RedPixelChannel]=ClampToQuantum(image->background_color.red);
469 pixel[GreenPixelChannel]=ClampToQuantum(image->background_color.green);
470 pixel[BluePixelChannel]=ClampToQuantum(image->background_color.blue);
471 pixel[BlackPixelChannel]=ClampToQuantum(image->background_color.black);
472 pixel[AlphaPixelChannel]=ClampToQuantum(image->background_color.alpha);
475 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
477 PixelChannel channel = GetPixelChannelChannel(image,i);
516static MagickBooleanType GetOneVirtualPixelFromStream(
const Image *image,
517 const VirtualPixelMethod virtual_pixel_method,
const ssize_t x,
const ssize_t y,
518 Quantum *pixel,ExceptionInfo *exception)
526 assert(image != (Image *) NULL);
527 assert(image->signature == MagickCoreSignature);
528 (void) memset(pixel,0,MaxPixelChannels*
sizeof(*pixel));
529 p=GetVirtualPixelStream(image,virtual_pixel_method,x,y,1,1,exception);
530 if (p == (
const Quantum *) NULL)
532 pixel[RedPixelChannel]=ClampToQuantum(image->background_color.red);
533 pixel[GreenPixelChannel]=ClampToQuantum(image->background_color.green);
534 pixel[BluePixelChannel]=ClampToQuantum(image->background_color.blue);
535 pixel[BlackPixelChannel]=ClampToQuantum(image->background_color.black);
536 pixel[AlphaPixelChannel]=ClampToQuantum(image->background_color.alpha);
539 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
541 PixelChannel channel = GetPixelChannelChannel(image,i);
569MagickPrivate
const void *GetStreamInfoClientData(StreamInfo *stream_info)
571 assert(stream_info != (StreamInfo *) NULL);
572 assert(stream_info->signature == MagickCoreSignature);
573 return(stream_info->client_data);
602static const Quantum *GetVirtualPixelsStream(
const Image *image)
607 assert(image != (Image *) NULL);
608 assert(image->signature == MagickCoreSignature);
609 if (IsEventLogging() != MagickFalse)
610 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
611 cache_info=(CacheInfo *) image->cache;
612 assert(cache_info->signature == MagickCoreSignature);
613 return(cache_info->pixels);
640static const void *GetVirtualMetacontentFromStream(
const Image *image)
645 assert(image != (Image *) NULL);
646 assert(image->signature == MagickCoreSignature);
647 if (IsEventLogging() != MagickFalse)
648 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
649 cache_info=(CacheInfo *) image->cache;
650 assert(cache_info->signature == MagickCoreSignature);
651 return(cache_info->metacontent);
690static inline MagickBooleanType AcquireStreamPixels(CacheInfo *cache_info,
691 ExceptionInfo *exception)
693 if (cache_info->length != (MagickSizeType) ((
size_t) cache_info->length))
695 cache_info->pixels=(Quantum *) MagickAssumeAligned(AcquireAlignedMemory(1,
696 (
size_t) cache_info->length));
697 if (cache_info->pixels != (Quantum *) NULL)
698 (void) memset(cache_info->pixels,0,(
size_t) cache_info->length);
701 (void) ThrowMagickException(exception,GetMagickModule(),
702 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",
703 cache_info->filename);
709static const Quantum *GetVirtualPixelStream(
const Image *image,
710 const VirtualPixelMethod magick_unused(virtual_pixel_method),
const ssize_t x,
711 const ssize_t y,
const size_t columns,
const size_t rows,
712 ExceptionInfo *exception)
727 magick_unreferenced(virtual_pixel_method);
732 assert(image != (
const Image *) NULL);
733 assert(image->signature == MagickCoreSignature);
734 if (IsEventLogging() != MagickFalse)
735 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
736 if ((x < 0) || (y < 0) ||
737 ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
738 ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
739 (columns == 0) || (rows == 0))
741 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
742 "ImageDoesNotContainTheStreamGeometry",
"`%s'",image->filename);
743 return((Quantum *) NULL);
745 cache_info=(CacheInfo *) image->cache;
746 assert(cache_info->signature == MagickCoreSignature);
750 packet_size=MagickMax(cache_info->number_channels,1)*
sizeof(Quantum);
751 if ((HeapOverflowCheckAdd(packet_size,cache_info->metacontent_extent) != MagickFalse) ||
752 (HeapOverflowSanityCheckGetSize(columns,rows,&length) != MagickFalse) ||
753 (HeapOverflowSanityCheckGetSize(length,packet_size+cache_info->metacontent_extent,&length) != MagickFalse))
755 (void) ThrowMagickException(exception,GetMagickModule(),
756 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
757 return((Quantum *) NULL);
759 number_pixels=(MagickSizeType) columns*rows;
760 if (cache_info->pixels == (Quantum *) NULL)
762 cache_info->length=length;
763 status=AcquireStreamPixels(cache_info,exception);
764 if (status == MagickFalse)
766 cache_info->length=0;
767 return((Quantum *) NULL);
771 if (cache_info->length < length)
773 RelinquishStreamPixels(cache_info);
774 cache_info->length=length;
775 status=AcquireStreamPixels(cache_info,exception);
776 if (status == MagickFalse)
778 cache_info->length=0;
779 return((Quantum *) NULL);
782 cache_info->metacontent=(
void *) NULL;
783 if (cache_info->metacontent_extent != 0)
784 cache_info->metacontent=(
void *) (cache_info->pixels+number_pixels*
785 cache_info->number_channels);
786 return(cache_info->pixels);
818MagickExport MagickBooleanType OpenStream(
const ImageInfo *image_info,
819 StreamInfo *stream_info,
const char *filename,ExceptionInfo *exception)
824 (void) CopyMagickString(stream_info->stream->filename,filename,
826 status=OpenBlob(image_info,stream_info->stream,WriteBinaryBlobMode,exception);
862static inline MagickBooleanType ValidatePixelCacheMorphology(
863 const Image *magick_restrict image)
866 *magick_restrict cache_info;
868 const PixelChannelMap
875 cache_info=(CacheInfo *) image->cache;
876 p=image->channel_map;
877 q=cache_info->channel_map;
878 if ((image->storage_class != cache_info->storage_class) ||
879 (image->colorspace != cache_info->colorspace) ||
880 (image->alpha_trait != cache_info->alpha_trait) ||
881 (image->channels != cache_info->channels) ||
882 (image->columns != cache_info->columns) ||
883 (image->rows != cache_info->rows) ||
884 (image->number_channels != cache_info->number_channels) ||
885 (memcmp(p,q,image->number_channels*
sizeof(*p)) != 0) ||
886 (image->metacontent_extent != cache_info->metacontent_extent) ||
887 (cache_info->nexus_info == (NexusInfo **) NULL))
892static Quantum *QueueAuthenticPixelsStream(Image *image,
const ssize_t x,
893 const ssize_t y,
const size_t columns,
const size_t rows,
894 ExceptionInfo *exception)
915 assert(image != (Image *) NULL);
916 if ((image->columns == 0) || (image->rows == 0) || (x < 0) ||
917 (y < 0) || (x >= (ssize_t) image->columns) ||
918 (y >= (ssize_t) image->rows))
920 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
921 "ImageDoesNotContainTheStreamGeometry",
"`%s'",image->filename);
922 return((Quantum *) NULL);
924 stream_handler=GetBlobStreamHandler(image);
925 if (stream_handler == (StreamHandler) NULL)
927 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
928 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
929 return((Quantum *) NULL);
931 cache_info=(CacheInfo *) image->cache;
932 assert(cache_info->signature == MagickCoreSignature);
933 if (ValidatePixelCacheMorphology(image) == MagickFalse)
935 if (cache_info->storage_class == UndefinedClass)
936 (void) stream_handler(image,(
const void *) NULL,(
size_t)
937 cache_info->columns);
938 cache_info->storage_class=image->storage_class;
939 cache_info->colorspace=image->colorspace;
940 cache_info->alpha_trait=image->alpha_trait;
941 cache_info->channels=image->channels;
942 cache_info->columns=image->columns;
943 cache_info->rows=image->rows;
944 cache_info->number_channels=image->number_channels;
945 status=ResetPixelChannelMap(image,exception);
946 if (status == MagickFalse)
947 return((Quantum *) NULL);
948 ResetPixelCacheChannels(image);
949 image->cache=cache_info;
954 cache_info->columns=columns;
955 cache_info->rows=rows;
956 packet_size=MagickMax(cache_info->number_channels,1)*
sizeof(Quantum);
957 if ((HeapOverflowCheckAdd(packet_size,cache_info->metacontent_extent) !=
959 (HeapOverflowSanityCheckGetSize(columns,rows,&length) != MagickFalse) ||
960 (HeapOverflowSanityCheckGetSize(length,
961 packet_size+cache_info->metacontent_extent,&length) != MagickFalse))
963 (void) ThrowMagickException(exception,GetMagickModule(),
964 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
965 return((Quantum *) NULL);
967 number_pixels=(MagickSizeType) columns*rows;
968 if (cache_info->pixels == (Quantum *) NULL)
970 cache_info->length=length;
971 status=AcquireStreamPixels(cache_info,exception);
972 if (status == MagickFalse)
974 cache_info->length=0;
975 return((Quantum *) NULL);
979 if (cache_info->length < length)
981 RelinquishStreamPixels(cache_info);
982 cache_info->length=length;
983 status=AcquireStreamPixels(cache_info,exception);
984 if (status == MagickFalse)
986 cache_info->length=0;
987 return((Quantum *) NULL);
990 cache_info->metacontent=(
void *) NULL;
991 if (cache_info->metacontent_extent != 0)
992 cache_info->metacontent=(
void *) (cache_info->pixels+number_pixels*
993 cache_info->number_channels);
994 return(cache_info->pixels);
1025MagickExport Image *ReadStream(
const ImageInfo *image_info,StreamHandler stream,
1026 ExceptionInfo *exception)
1040 assert(image_info != (ImageInfo *) NULL);
1041 assert(image_info->signature == MagickCoreSignature);
1042 assert(exception != (ExceptionInfo *) NULL);
1043 assert(exception->signature == MagickCoreSignature);
1044 if (IsEventLogging() != MagickFalse)
1045 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1046 image_info->filename);
1047 read_info=CloneImageInfo(image_info);
1048 read_info->cache=AcquirePixelCache(0);
1049 GetPixelCacheMethods(&cache_methods);
1050 cache_methods.get_virtual_pixel_handler=GetVirtualPixelStream;
1051 cache_methods.get_virtual_pixels_handler=GetVirtualPixelsStream;
1052 cache_methods.get_virtual_metacontent_from_handler=
1053 GetVirtualMetacontentFromStream;
1054 cache_methods.get_authentic_pixels_handler=GetAuthenticPixelsStream;
1055 cache_methods.queue_authentic_pixels_handler=QueueAuthenticPixelsStream;
1056 cache_methods.sync_authentic_pixels_handler=SyncAuthenticPixelsStream;
1057 cache_methods.get_authentic_pixels_from_handler=GetAuthenticPixelsFromStream;
1058 cache_methods.get_authentic_metacontent_from_handler=
1059 GetAuthenticMetacontentFromStream;
1060 cache_methods.get_one_virtual_pixel_from_handler=GetOneVirtualPixelFromStream;
1061 cache_methods.get_one_authentic_pixel_from_handler=
1062 GetOneAuthenticPixelFromStream;
1063 cache_methods.destroy_pixel_handler=DestroyPixelStream;
1064 SetPixelCacheMethods(read_info->cache,&cache_methods);
1065 read_info->stream=stream;
1066 image=ReadImage(read_info,exception);
1067 read_info=DestroyImageInfo(read_info);
1068 if (image != (Image *) NULL)
1070 MagickBooleanType status = ResetPixelChannelMap(image,exception);
1071 if (status == MagickFalse)
1072 return(DestroyImage(image));
1073 ResetPixelCacheChannels(image);
1096MagickPrivate
void ResetStreamAnonymousMemory(
void)
1125MagickPrivate
void SetStreamInfoClientData(StreamInfo *stream_info,
1126 const void *client_data)
1128 assert(stream_info != (StreamInfo *) NULL);
1129 assert(stream_info->signature == MagickCoreSignature);
1130 stream_info->client_data=client_data;
1157MagickExport
void SetStreamInfoMap(StreamInfo *stream_info,
const char *map)
1159 assert(stream_info != (StreamInfo *) NULL);
1160 assert(stream_info->signature == MagickCoreSignature);
1161 (void) CloneString(&stream_info->map,map);
1189MagickExport
void SetStreamInfoStorageType(StreamInfo *stream_info,
1190 const StorageType storage_type)
1192 assert(stream_info != (StreamInfo *) NULL);
1193 assert(stream_info->signature == MagickCoreSignature);
1194 stream_info->storage_type=storage_type;
1226#if defined(__cplusplus) || defined(c_plusplus)
1230static size_t WriteStreamImage(
const Image *image,
const void *pixels,
1231 const size_t columns)
1250 stream_info=(StreamInfo *) image->client_data;
1251 switch (stream_info->storage_type)
1253 default: packet_size=
sizeof(
unsigned char);
break;
1254 case CharPixel: packet_size=
sizeof(
unsigned char);
break;
1255 case DoublePixel: packet_size=
sizeof(double);
break;
1256 case FloatPixel: packet_size=
sizeof(float);
break;
1257 case LongPixel: packet_size=
sizeof(
unsigned int);
break;
1258 case LongLongPixel: packet_size=
sizeof(MagickSizeType);
break;
1259 case QuantumPixel: packet_size=
sizeof(Quantum);
break;
1260 case ShortPixel: packet_size=
sizeof(
unsigned short);
break;
1262 cache_info=(CacheInfo *) image->cache;
1263 assert(cache_info->signature == MagickCoreSignature);
1264 packet_size*=strlen(stream_info->map);
1265 length=packet_size*cache_info->columns*cache_info->rows;
1266 if ((image != stream_info->image) || (length > stream_info->length))
1274 (void) RelinquishAlignedMemory(stream_info->pixels);
1275 stream_info->pixels=(
unsigned char *) AcquireAlignedMemory(1,length);
1276 if (stream_info->pixels == (
unsigned char *) NULL)
1278 (void) memset(stream_info->pixels,0,length);
1279 stream_info->length=length;
1280 stream_info->image=image;
1281 write_info=CloneImageInfo(stream_info->image_info);
1282 (void) SetImageInfo(write_info,1,stream_info->exception);
1283 if (write_info->extract != (
char *) NULL)
1284 (void) ParseAbsoluteGeometry(write_info->extract,
1285 &stream_info->extract_info);
1287 write_info=DestroyImageInfo(write_info);
1289 extract_info=stream_info->extract_info;
1290 if ((extract_info.width == 0) || (extract_info.height == 0))
1295 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1296 count=WriteBlob(stream_info->stream,length,stream_info->pixels);
1298 return(count == 0 ? 0 : columns);
1300 if ((stream_info->y < extract_info.y) ||
1301 (stream_info->y >= (extract_info.y+(ssize_t) extract_info.height)))
1309 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1311 if ((extract_info.x < (ssize_t) image->columns) &&
1312 ((extract_info.x + (ssize_t) extract_info.width) > 0))
1314 ssize_t x = extract_info.x;
1315 size_t width = extract_info.width;
1321 if ((x+(ssize_t) width) > (ssize_t) image->columns)
1322 width=(size_t) ((ssize_t) image->columns-x);
1323 length=packet_size*width;
1324 count=WriteBlob(stream_info->stream,length,stream_info->pixels+
1328 return(count == 0 ? 0 : columns);
1331#if defined(__cplusplus) || defined(c_plusplus)
1335MagickExport Image *StreamImage(
const ImageInfo *image_info,
1336 StreamInfo *stream_info,ExceptionInfo *exception)
1344 assert(image_info != (
const ImageInfo *) NULL);
1345 assert(image_info->signature == MagickCoreSignature);
1346 assert(stream_info != (StreamInfo *) NULL);
1347 assert(stream_info->signature == MagickCoreSignature);
1348 assert(exception != (ExceptionInfo *) NULL);
1349 if (IsEventLogging() != MagickFalse)
1350 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1351 image_info->filename);
1352 read_info=CloneImageInfo(image_info);
1353 stream_info->image_info=image_info;
1354 if (stream_info->quantum_info == (QuantumInfo *) NULL)
1355 stream_info->quantum_info=AcquireQuantumInfo(image_info,(Image *) NULL);
1356 if (stream_info->quantum_info == (QuantumInfo *) NULL)
1358 read_info=DestroyImageInfo(read_info);
1359 return((Image *) NULL);
1361 stream_info->exception=exception;
1362 read_info->client_data=(
void *) stream_info;
1363 image=ReadStream(read_info,&WriteStreamImage,exception);
1364 read_info=DestroyImageInfo(read_info);
1365 stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
1366 stream_info->quantum_info=AcquireQuantumInfo(image_info,image);
1367 if (stream_info->quantum_info == (QuantumInfo *) NULL)
1368 image=DestroyImage(image);
1401static MagickBooleanType StreamImagePixels(
const StreamInfo *stream_info,
1402 const Image *image,ExceptionInfo *exception)
1420 assert(stream_info != (StreamInfo *) NULL);
1421 assert(stream_info->signature == MagickCoreSignature);
1422 assert(image != (Image *) NULL);
1423 assert(image->signature == MagickCoreSignature);
1424 if (IsEventLogging() != MagickFalse)
1425 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1426 length=strlen(stream_info->map);
1427 quantum_map=(QuantumType *) AcquireQuantumMemory(length,
sizeof(*quantum_map));
1428 if (quantum_map == (QuantumType *) NULL)
1430 (void) ThrowMagickException(exception,GetMagickModule(),
1431 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1432 return(MagickFalse);
1434 (void) memset(quantum_map,0,length*
sizeof(*quantum_map));
1435 for (i=0; i < (ssize_t) length; i++)
1437 switch (stream_info->map[i])
1442 quantum_map[i]=AlphaQuantum;
1448 quantum_map[i]=BlueQuantum;
1454 quantum_map[i]=CyanQuantum;
1455 if (image->colorspace == CMYKColorspace)
1457 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1458 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1459 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1460 return(MagickFalse);
1465 quantum_map[i]=GreenQuantum;
1471 quantum_map[i]=IndexQuantum;
1477 quantum_map[i]=BlackQuantum;
1478 if (image->colorspace == CMYKColorspace)
1480 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1481 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1482 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1483 return(MagickFalse);
1488 quantum_map[i]=MagentaQuantum;
1489 if (image->colorspace == CMYKColorspace)
1491 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1492 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1493 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1494 return(MagickFalse);
1499 quantum_map[i]=OpacityQuantum;
1505 quantum_map[i]=UndefinedQuantum;
1511 quantum_map[i]=RedQuantum;
1517 quantum_map[i]=YellowQuantum;
1518 if (image->colorspace == CMYKColorspace)
1520 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1521 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1522 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1523 return(MagickFalse);
1527 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1528 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1529 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
1530 return(MagickFalse);
1534 quantum_info=stream_info->quantum_info;
1535 switch (stream_info->storage_type)
1542 q=(
unsigned char *) stream_info->pixels;
1543 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1545 p=GetAuthenticPixelQueue(image);
1546 if (p == (
const Quantum *) NULL)
1548 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1550 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1551 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1552 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1553 p+=(ptrdiff_t) GetPixelChannels(image);
1557 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1559 p=GetAuthenticPixelQueue(image);
1560 if (p == (
const Quantum *) NULL)
1562 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1564 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1565 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1566 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1567 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
1568 p+=(ptrdiff_t) GetPixelChannels(image);
1572 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1574 p=GetAuthenticPixelQueue(image);
1575 if (p == (
const Quantum *) NULL)
1577 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1579 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1580 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1581 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1582 *q++=ScaleQuantumToChar((Quantum) 0);
1583 p+=(ptrdiff_t) GetPixelChannels(image);
1587 if (LocaleCompare(stream_info->map,
"I") == 0)
1589 p=GetAuthenticPixelQueue(image);
1590 if (p == (
const Quantum *) NULL)
1592 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1594 *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1595 p+=(ptrdiff_t) GetPixelChannels(image);
1599 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1601 p=GetAuthenticPixelQueue(image);
1602 if (p == (
const Quantum *) NULL)
1604 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1606 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1607 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1608 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1609 p+=(ptrdiff_t) GetPixelChannels(image);
1613 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1615 p=GetAuthenticPixelQueue(image);
1616 if (p == (
const Quantum *) NULL)
1618 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1620 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1621 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1622 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1623 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
1624 p+=(ptrdiff_t) GetPixelChannels(image);
1628 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1630 p=GetAuthenticPixelQueue(image);
1631 if (p == (
const Quantum *) NULL)
1633 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1635 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1636 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1637 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1638 *q++=ScaleQuantumToChar((Quantum) 0);
1639 p+=(ptrdiff_t) GetPixelChannels(image);
1643 p=GetAuthenticPixelQueue(image);
1644 if (p == (
const Quantum *) NULL)
1646 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1648 for (i=0; i < (ssize_t) length; i++)
1651 switch (quantum_map[i])
1656 *q=ScaleQuantumToChar(GetPixelRed(image,p));
1660 case MagentaQuantum:
1662 *q=ScaleQuantumToChar(GetPixelGreen(image,p));
1668 *q=ScaleQuantumToChar(GetPixelBlue(image,p));
1673 *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
1676 case OpacityQuantum:
1678 *q=ScaleQuantumToChar(GetPixelOpacity(image,p));
1683 if (image->colorspace == CMYKColorspace)
1684 *q=ScaleQuantumToChar(GetPixelBlack(image,p));
1689 *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1697 p+=(ptrdiff_t) GetPixelChannels(image);
1706 q=(
double *) stream_info->pixels;
1707 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1709 p=GetAuthenticPixelQueue(image);
1710 if (p == (
const Quantum *) NULL)
1712 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1714 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1715 quantum_info->scale+quantum_info->minimum);
1716 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1717 quantum_info->scale+quantum_info->minimum);
1718 *q++=(double) ((QuantumScale*(
double) GetPixelRed(image,p))*
1719 quantum_info->scale+quantum_info->minimum);
1720 p+=(ptrdiff_t) GetPixelChannels(image);
1724 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1726 p=GetAuthenticPixelQueue(image);
1727 if (p == (
const Quantum *) NULL)
1729 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1731 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1732 quantum_info->scale+quantum_info->minimum);
1733 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1734 quantum_info->scale+quantum_info->minimum);
1735 *q++=(double) ((QuantumScale*(
double) GetPixelRed(image,p))*
1736 quantum_info->scale+quantum_info->minimum);
1737 *q++=(double) ((QuantumScale*(
double) GetPixelAlpha(image,p))*
1738 quantum_info->scale+quantum_info->minimum);
1739 p+=(ptrdiff_t) GetPixelChannels(image);
1743 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1745 p=GetAuthenticPixelQueue(image);
1746 if (p == (
const Quantum *) NULL)
1748 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1750 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1751 quantum_info->scale+quantum_info->minimum);
1752 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1753 quantum_info->scale+quantum_info->minimum);
1754 *q++=(double) ((QuantumScale*(
double) GetPixelRed(image,p))*
1755 quantum_info->scale+quantum_info->minimum);
1757 p+=(ptrdiff_t) GetPixelChannels(image);
1761 if (LocaleCompare(stream_info->map,
"I") == 0)
1763 p=GetAuthenticPixelQueue(image);
1764 if (p == (
const Quantum *) NULL)
1766 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1768 *q++=(double) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1769 quantum_info->scale+quantum_info->minimum);
1770 p+=(ptrdiff_t) GetPixelChannels(image);
1774 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1776 p=GetAuthenticPixelQueue(image);
1777 if (p == (
const Quantum *) NULL)
1779 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1781 *q++=(double) ((QuantumScale*(
double) GetPixelRed(image,p))*
1782 quantum_info->scale+quantum_info->minimum);
1783 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1784 quantum_info->scale+quantum_info->minimum);
1785 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1786 quantum_info->scale+quantum_info->minimum);
1787 p+=(ptrdiff_t) GetPixelChannels(image);
1791 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1793 p=GetAuthenticPixelQueue(image);
1794 if (p == (
const Quantum *) NULL)
1796 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1798 *q++=(double) ((QuantumScale*(
double) GetPixelRed(image,p))*
1799 quantum_info->scale+quantum_info->minimum);
1800 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1801 quantum_info->scale+quantum_info->minimum);
1802 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1803 quantum_info->scale+quantum_info->minimum);
1804 *q++=(double) ((QuantumScale*(
double) GetPixelAlpha(image,p))*
1805 quantum_info->scale+quantum_info->minimum);
1806 p+=(ptrdiff_t) GetPixelChannels(image);
1810 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1812 p=GetAuthenticPixelQueue(image);
1813 if (p == (
const Quantum *) NULL)
1815 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1817 *q++=(double) ((QuantumScale*(
double) GetPixelRed(image,p))*
1818 quantum_info->scale+quantum_info->minimum);
1819 *q++=(double) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1820 quantum_info->scale+quantum_info->minimum);
1821 *q++=(double) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1822 quantum_info->scale+quantum_info->minimum);
1824 p+=(ptrdiff_t) GetPixelChannels(image);
1828 p=GetAuthenticPixelQueue(image);
1829 if (p == (
const Quantum *) NULL)
1831 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1833 for (i=0; i < (ssize_t) length; i++)
1836 switch (quantum_map[i])
1841 *q=(double) ((QuantumScale*(
double) GetPixelRed(image,p))*
1842 quantum_info->scale+quantum_info->minimum);
1846 case MagentaQuantum:
1848 *q=(double) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1849 quantum_info->scale+quantum_info->minimum);
1855 *q=(double) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1856 quantum_info->scale+quantum_info->minimum);
1861 *q=(double) ((QuantumScale*(
double) GetPixelAlpha(image,p))*
1862 quantum_info->scale+quantum_info->minimum);
1865 case OpacityQuantum:
1867 *q=(double) ((QuantumScale*(
double) GetPixelOpacity(image,p))*
1868 quantum_info->scale+quantum_info->minimum);
1873 if (image->colorspace == CMYKColorspace)
1874 *q=(double) ((QuantumScale*(
double) GetPixelBlack(image,p))*
1875 quantum_info->scale+quantum_info->minimum);
1880 *q=(double) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1881 quantum_info->scale+quantum_info->minimum);
1889 p+=(ptrdiff_t) GetPixelChannels(image);
1898 q=(
float *) stream_info->pixels;
1899 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1901 p=GetAuthenticPixelQueue(image);
1902 if (p == (
const Quantum *) NULL)
1904 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1906 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1907 quantum_info->scale+quantum_info->minimum);
1908 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1909 quantum_info->scale+quantum_info->minimum);
1910 *q++=(float) ((QuantumScale*(
double) GetPixelRed(image,p))*
1911 quantum_info->scale+quantum_info->minimum);
1912 p+=(ptrdiff_t) GetPixelChannels(image);
1916 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1918 p=GetAuthenticPixelQueue(image);
1919 if (p == (
const Quantum *) NULL)
1921 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1923 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1924 quantum_info->scale+quantum_info->minimum);
1925 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1926 quantum_info->scale+quantum_info->minimum);
1927 *q++=(float) ((QuantumScale*(
double) GetPixelRed(image,p))*
1928 quantum_info->scale+quantum_info->minimum);
1929 *q++=(float) ((QuantumScale*(
double) GetPixelAlpha(image,p))*
1930 quantum_info->scale+quantum_info->minimum);
1931 p+=(ptrdiff_t) GetPixelChannels(image);
1935 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1937 p=GetAuthenticPixelQueue(image);
1938 if (p == (
const Quantum *) NULL)
1940 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1942 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1943 quantum_info->scale+quantum_info->minimum);
1944 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1945 quantum_info->scale+quantum_info->minimum);
1946 *q++=(float) ((QuantumScale*(
double) GetPixelRed(image,p))*
1947 quantum_info->scale+quantum_info->minimum);
1949 p+=(ptrdiff_t) GetPixelChannels(image);
1953 if (LocaleCompare(stream_info->map,
"I") == 0)
1955 p=GetAuthenticPixelQueue(image);
1956 if (p == (
const Quantum *) NULL)
1958 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1960 *q++=(float) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
1961 quantum_info->scale+quantum_info->minimum);
1962 p+=(ptrdiff_t) GetPixelChannels(image);
1966 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1968 p=GetAuthenticPixelQueue(image);
1969 if (p == (
const Quantum *) NULL)
1971 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1973 *q++=(float) ((QuantumScale*(
double) GetPixelRed(image,p))*
1974 quantum_info->scale+quantum_info->minimum);
1975 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1976 quantum_info->scale+quantum_info->minimum);
1977 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1978 quantum_info->scale+quantum_info->minimum);
1979 p+=(ptrdiff_t) GetPixelChannels(image);
1983 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1985 p=GetAuthenticPixelQueue(image);
1986 if (p == (
const Quantum *) NULL)
1988 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1990 *q++=(float) ((QuantumScale*(
double) GetPixelRed(image,p))*
1991 quantum_info->scale+quantum_info->minimum);
1992 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(image,p))*
1993 quantum_info->scale+quantum_info->minimum);
1994 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(image,p))*
1995 quantum_info->scale+quantum_info->minimum);
1996 *q++=(float) ((QuantumScale*(
double) GetPixelAlpha(image,p))*
1997 quantum_info->scale+quantum_info->minimum);
1998 p+=(ptrdiff_t) GetPixelChannels(image);
2002 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2004 p=GetAuthenticPixelQueue(image);
2005 if (p == (
const Quantum *) NULL)
2007 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2009 *q++=(float) ((QuantumScale*(
double) GetPixelRed(image,p))*
2010 quantum_info->scale+quantum_info->minimum);
2011 *q++=(float) ((QuantumScale*(
double) GetPixelGreen(image,p))*
2012 quantum_info->scale+quantum_info->minimum);
2013 *q++=(float) ((QuantumScale*(
double) GetPixelBlue(image,p))*
2014 quantum_info->scale+quantum_info->minimum);
2016 p+=(ptrdiff_t) GetPixelChannels(image);
2020 p=GetAuthenticPixelQueue(image);
2021 if (p == (
const Quantum *) NULL)
2023 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2025 for (i=0; i < (ssize_t) length; i++)
2028 switch (quantum_map[i])
2033 *q=(float) ((QuantumScale*(
double) GetPixelRed(image,p))*
2034 quantum_info->scale+quantum_info->minimum);
2038 case MagentaQuantum:
2040 *q=(float) ((QuantumScale*(
double) GetPixelGreen(image,p))*
2041 quantum_info->scale+quantum_info->minimum);
2047 *q=(float) ((QuantumScale*(
double) GetPixelBlue(image,p))*
2048 quantum_info->scale+quantum_info->minimum);
2053 *q=(float) ((QuantumScale*(
double) GetPixelAlpha(image,p))*
2054 quantum_info->scale+quantum_info->minimum);
2057 case OpacityQuantum:
2059 *q=(float) ((QuantumScale*(
double) GetPixelOpacity(image,p))*
2060 quantum_info->scale+quantum_info->minimum);
2065 if (image->colorspace == CMYKColorspace)
2066 *q=(float) ((QuantumScale*(
double) GetPixelBlack(image,p))*
2067 quantum_info->scale+quantum_info->minimum);
2072 *q=(float) ((QuantumScale*(
double) GetPixelIntensity(image,p))*
2073 quantum_info->scale+quantum_info->minimum);
2081 p+=(ptrdiff_t) GetPixelChannels(image);
2090 q=(
unsigned int *) stream_info->pixels;
2091 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2093 p=GetAuthenticPixelQueue(image);
2094 if (p == (
const Quantum *) NULL)
2096 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2098 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2099 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2100 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2101 p+=(ptrdiff_t) GetPixelChannels(image);
2105 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2107 p=GetAuthenticPixelQueue(image);
2108 if (p == (
const Quantum *) NULL)
2110 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2112 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2113 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2114 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2115 *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
2116 p+=(ptrdiff_t) GetPixelChannels(image);
2120 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2122 p=GetAuthenticPixelQueue(image);
2123 if (p == (
const Quantum *) NULL)
2125 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2127 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2128 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2129 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2131 p+=(ptrdiff_t) GetPixelChannels(image);
2135 if (LocaleCompare(stream_info->map,
"I") == 0)
2137 p=GetAuthenticPixelQueue(image);
2138 if (p == (
const Quantum *) NULL)
2140 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2142 *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2143 p+=(ptrdiff_t) GetPixelChannels(image);
2147 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2149 p=GetAuthenticPixelQueue(image);
2150 if (p == (
const Quantum *) NULL)
2152 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2154 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2155 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2156 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2157 p+=(ptrdiff_t) GetPixelChannels(image);
2161 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2163 p=GetAuthenticPixelQueue(image);
2164 if (p == (
const Quantum *) NULL)
2166 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2168 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2169 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2170 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2171 *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
2172 p+=(ptrdiff_t) GetPixelChannels(image);
2176 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2178 p=GetAuthenticPixelQueue(image);
2179 if (p == (
const Quantum *) NULL)
2181 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2183 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2184 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2185 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2187 p+=(ptrdiff_t) GetPixelChannels(image);
2191 p=GetAuthenticPixelQueue(image);
2192 if (p == (
const Quantum *) NULL)
2194 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2196 for (i=0; i < (ssize_t) length; i++)
2199 switch (quantum_map[i])
2204 *q=ScaleQuantumToLong(GetPixelRed(image,p));
2208 case MagentaQuantum:
2210 *q=ScaleQuantumToLong(GetPixelGreen(image,p));
2216 *q=ScaleQuantumToLong(GetPixelBlue(image,p));
2221 *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
2224 case OpacityQuantum:
2226 *q=ScaleQuantumToLong(GetPixelOpacity(image,p));
2231 if (image->colorspace == CMYKColorspace)
2232 *q=ScaleQuantumToLong(GetPixelBlack(image,p));
2237 *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2245 p+=(ptrdiff_t) GetPixelChannels(image);
2254 q=(MagickSizeType *) stream_info->pixels;
2255 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2257 p=GetAuthenticPixelQueue(image);
2258 if (p == (
const Quantum *) NULL)
2260 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2262 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2263 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2264 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2265 p+=(ptrdiff_t) GetPixelChannels(image);
2269 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2271 p=GetAuthenticPixelQueue(image);
2272 if (p == (
const Quantum *) NULL)
2274 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2276 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2277 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2278 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2279 *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2280 p+=(ptrdiff_t) GetPixelChannels(image);
2284 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2286 p=GetAuthenticPixelQueue(image);
2287 if (p == (
const Quantum *) NULL)
2289 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2291 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2292 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2293 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2295 p+=(ptrdiff_t) GetPixelChannels(image);
2299 if (LocaleCompare(stream_info->map,
"I") == 0)
2301 p=GetAuthenticPixelQueue(image);
2302 if (p == (
const Quantum *) NULL)
2304 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2306 *q++=ScaleQuantumToLongLong(ClampToQuantum(
2307 GetPixelIntensity(image,p)));
2308 p+=(ptrdiff_t) GetPixelChannels(image);
2312 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2314 p=GetAuthenticPixelQueue(image);
2315 if (p == (
const Quantum *) NULL)
2317 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2319 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2320 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2321 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2322 p+=(ptrdiff_t) GetPixelChannels(image);
2326 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2328 p=GetAuthenticPixelQueue(image);
2329 if (p == (
const Quantum *) NULL)
2331 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2333 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2334 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2335 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2336 *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2337 p+=(ptrdiff_t) GetPixelChannels(image);
2341 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2343 p=GetAuthenticPixelQueue(image);
2344 if (p == (
const Quantum *) NULL)
2346 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2348 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2349 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2350 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2352 p+=(ptrdiff_t) GetPixelChannels(image);
2356 p=GetAuthenticPixelQueue(image);
2357 if (p == (
const Quantum *) NULL)
2359 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2361 for (i=0; i < (ssize_t) length; i++)
2364 switch (quantum_map[i])
2369 *q=ScaleQuantumToLongLong(GetPixelRed(image,p));
2373 case MagentaQuantum:
2375 *q=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2381 *q=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2386 *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2389 case OpacityQuantum:
2391 *q=ScaleQuantumToLongLong(GetPixelOpacity(image,p));
2396 if (image->colorspace == CMYKColorspace)
2397 *q=ScaleQuantumToLongLong(GetPixelBlack(image,p));
2402 *q=ScaleQuantumToLongLong(ClampToQuantum(
2403 GetPixelIntensity(image,p)));
2411 p+=(ptrdiff_t) GetPixelChannels(image);
2420 q=(Quantum *) stream_info->pixels;
2421 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2423 p=GetAuthenticPixelQueue(image);
2424 if (p == (
const Quantum *) NULL)
2426 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2428 *q++=GetPixelBlue(image,p);
2429 *q++=GetPixelGreen(image,p);
2430 *q++=GetPixelRed(image,p);
2431 p+=(ptrdiff_t) GetPixelChannels(image);
2435 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2437 p=GetAuthenticPixelQueue(image);
2438 if (p == (
const Quantum *) NULL)
2440 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2442 *q++=GetPixelBlue(image,p);
2443 *q++=GetPixelGreen(image,p);
2444 *q++=GetPixelRed(image,p);
2445 *q++=GetPixelAlpha(image,p);
2446 p+=(ptrdiff_t) GetPixelChannels(image);
2450 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2452 p=GetAuthenticPixelQueue(image);
2453 if (p == (
const Quantum *) NULL)
2455 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2457 *q++=GetPixelBlue(image,p);
2458 *q++=GetPixelGreen(image,p);
2459 *q++=GetPixelRed(image,p);
2461 p+=(ptrdiff_t) GetPixelChannels(image);
2465 if (LocaleCompare(stream_info->map,
"I") == 0)
2467 p=GetAuthenticPixelQueue(image);
2468 if (p == (
const Quantum *) NULL)
2470 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2472 *q++=ClampToQuantum(GetPixelIntensity(image,p));
2473 p+=(ptrdiff_t) GetPixelChannels(image);
2477 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2479 p=GetAuthenticPixelQueue(image);
2480 if (p == (
const Quantum *) NULL)
2482 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2484 *q++=GetPixelRed(image,p);
2485 *q++=GetPixelGreen(image,p);
2486 *q++=GetPixelBlue(image,p);
2487 p+=(ptrdiff_t) GetPixelChannels(image);
2491 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2493 p=GetAuthenticPixelQueue(image);
2494 if (p == (
const Quantum *) NULL)
2496 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2498 *q++=GetPixelRed(image,p);
2499 *q++=GetPixelGreen(image,p);
2500 *q++=GetPixelBlue(image,p);
2501 *q++=GetPixelAlpha(image,p);
2502 p+=(ptrdiff_t) GetPixelChannels(image);
2506 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2508 p=GetAuthenticPixelQueue(image);
2509 if (p == (
const Quantum *) NULL)
2511 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2513 *q++=GetPixelRed(image,p);
2514 *q++=GetPixelGreen(image,p);
2515 *q++=GetPixelBlue(image,p);
2517 p+=(ptrdiff_t) GetPixelChannels(image);
2521 p=GetAuthenticPixelQueue(image);
2522 if (p == (
const Quantum *) NULL)
2524 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2526 for (i=0; i < (ssize_t) length; i++)
2529 switch (quantum_map[i])
2534 *q=GetPixelRed(image,p);
2538 case MagentaQuantum:
2540 *q=GetPixelGreen(image,p);
2546 *q=GetPixelBlue(image,p);
2551 *q=GetPixelAlpha(image,p);
2554 case OpacityQuantum:
2556 *q=GetPixelOpacity(image,p);
2561 if (image->colorspace == CMYKColorspace)
2562 *q=GetPixelBlack(image,p);
2567 *q=ClampToQuantum(GetPixelIntensity(image,p));
2575 p+=(ptrdiff_t) GetPixelChannels(image);
2584 q=(
unsigned short *) stream_info->pixels;
2585 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2587 p=GetAuthenticPixelQueue(image);
2588 if (p == (
const Quantum *) NULL)
2590 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2592 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2593 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2594 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2595 p+=(ptrdiff_t) GetPixelChannels(image);
2599 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2601 p=GetAuthenticPixelQueue(image);
2602 if (p == (
const Quantum *) NULL)
2604 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2606 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2607 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2608 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2609 *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
2610 p+=(ptrdiff_t) GetPixelChannels(image);
2614 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2616 p=GetAuthenticPixelQueue(image);
2617 if (p == (
const Quantum *) NULL)
2619 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2621 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2622 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2623 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2625 p+=(ptrdiff_t) GetPixelChannels(image);
2629 if (LocaleCompare(stream_info->map,
"I") == 0)
2631 p=GetAuthenticPixelQueue(image);
2632 if (p == (
const Quantum *) NULL)
2634 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2636 *q++=ScaleQuantumToShort(ClampToQuantum(
2637 GetPixelIntensity(image,p)));
2638 p+=(ptrdiff_t) GetPixelChannels(image);
2642 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2644 p=GetAuthenticPixelQueue(image);
2645 if (p == (
const Quantum *) NULL)
2647 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2649 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2650 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2651 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2652 p+=(ptrdiff_t) GetPixelChannels(image);
2656 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2658 p=GetAuthenticPixelQueue(image);
2659 if (p == (
const Quantum *) NULL)
2661 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2663 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2664 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2665 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2666 *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
2667 p+=(ptrdiff_t) GetPixelChannels(image);
2671 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2673 p=GetAuthenticPixelQueue(image);
2674 if (p == (
const Quantum *) NULL)
2676 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2678 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2679 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2680 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2682 p+=(ptrdiff_t) GetPixelChannels(image);
2686 p=GetAuthenticPixelQueue(image);
2687 if (p == (
const Quantum *) NULL)
2689 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2691 for (i=0; i < (ssize_t) length; i++)
2694 switch (quantum_map[i])
2699 *q=ScaleQuantumToShort(GetPixelRed(image,p));
2703 case MagentaQuantum:
2705 *q=ScaleQuantumToShort(GetPixelGreen(image,p));
2711 *q=ScaleQuantumToShort(GetPixelBlue(image,p));
2716 *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
2719 case OpacityQuantum:
2721 *q=ScaleQuantumToShort(GetPixelOpacity(image,p));
2726 if (image->colorspace == CMYKColorspace)
2727 *q=ScaleQuantumToShort(GetPixelBlack(image,p));
2732 *q=ScaleQuantumToShort(ClampToQuantum(
2733 GetPixelIntensity(image,p)));
2741 p+=(ptrdiff_t) GetPixelChannels(image);
2747 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2748 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2749 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
2753 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2783static MagickBooleanType SyncAuthenticPixelsStream(Image *image,
2784 ExceptionInfo *exception)
2795 assert(image != (Image *) NULL);
2796 assert(image->signature == MagickCoreSignature);
2797 if (IsEventLogging() != MagickFalse)
2798 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2799 cache_info=(CacheInfo *) image->cache;
2800 assert(cache_info->signature == MagickCoreSignature);
2801 stream_handler=GetBlobStreamHandler(image);
2802 if (stream_handler == (StreamHandler) NULL)
2804 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
2805 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
2806 return(MagickFalse);
2808 length=stream_handler(image,cache_info->pixels,(
size_t) cache_info->columns);
2809 return(length == cache_info->columns ? MagickTrue : MagickFalse);
2840MagickExport MagickBooleanType WriteStream(
const ImageInfo *image_info,
2841 Image *image,StreamHandler stream,ExceptionInfo *exception)
2849 assert(image_info != (ImageInfo *) NULL);
2850 assert(image_info->signature == MagickCoreSignature);
2851 if (IsEventLogging() != MagickFalse)
2852 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2853 image_info->filename);
2854 assert(image != (Image *) NULL);
2855 assert(image->signature == MagickCoreSignature);
2856 write_info=CloneImageInfo(image_info);
2857 *write_info->magick=
'\0';
2858 write_info->stream=stream;
2859 status=WriteImage(write_info,image,exception);
2860 write_info=DestroyImageInfo(write_info);