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/policy.h"
59 #include "MagickCore/quantum.h"
60 #include "MagickCore/quantum-private.h"
61 #include "MagickCore/semaphore.h"
62 #include "MagickCore/stream.h"
63 #include "MagickCore/stream-private.h"
64 #include "MagickCore/string_.h"
111 #if defined(__cplusplus) || defined(c_plusplus)
116 *GetVirtualPixelStream(
const Image *,
const VirtualPixelMethod,
const ssize_t,
119 static MagickBooleanType
124 *QueueAuthenticPixelsStream(
Image *,
const ssize_t,
const ssize_t,
const size_t,
127 #if defined(__cplusplus) || defined(c_plusplus)
162 stream_info=(
StreamInfo *) AcquireCriticalMemory(
sizeof(*stream_info));
163 (void) memset(stream_info,0,
sizeof(*stream_info));
164 stream_info->pixels=(
unsigned char *) MagickAssumeAligned(
165 AcquireAlignedMemory(1,
sizeof(*stream_info->pixels)));
166 if (stream_info->pixels == (
unsigned char *) NULL)
167 ThrowFatalException(ResourceLimitFatalError,
"MemoryAllocationFailed");
168 stream_info->map=ConstantString(
"RGB");
169 stream_info->storage_type=CharPixel;
170 stream_info->stream=AcquireImage(image_info,exception);
171 stream_info->signature=MagickCoreSignature;
198 static inline void RelinquishStreamPixels(
CacheInfo *cache_info)
200 assert(cache_info != (
CacheInfo *) NULL);
201 if (cache_info->pixels != (Quantum *) NULL)
203 if (cache_info->mapped == MagickFalse)
204 cache_info->pixels=(Quantum *) RelinquishAlignedMemory(
208 (void) UnmapBlob(cache_info->pixels,(
size_t) cache_info->length);
209 cache_info->pixels=(Quantum *) NULL;
212 cache_info->mapped=MagickFalse;
213 cache_info->metacontent=(
void *) NULL;
214 cache_info->length=0;
217 static void DestroyPixelStream(
Image *image)
225 assert(image != (
Image *) NULL);
226 assert(image->signature == MagickCoreSignature);
227 if (IsEventLogging() != MagickFalse)
228 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
230 assert(cache_info->signature == MagickCoreSignature);
232 LockSemaphoreInfo(cache_info->semaphore);
233 cache_info->reference_count--;
234 if (cache_info->reference_count == 0)
236 UnlockSemaphoreInfo(cache_info->semaphore);
237 if (destroy == MagickFalse)
239 RelinquishStreamPixels(cache_info);
240 if (cache_info->nexus_info != (
NexusInfo **) NULL)
241 cache_info->nexus_info=DestroyPixelCacheNexus(cache_info->nexus_info,
242 cache_info->number_threads);
244 RelinquishSemaphoreInfo(&cache_info->file_semaphore);
246 RelinquishSemaphoreInfo(&cache_info->semaphore);
247 cache_info=(
CacheInfo *) RelinquishAlignedMemory(cache_info);
276 assert(stream_info->signature == MagickCoreSignature);
277 if (IsEventLogging() != MagickFalse)
278 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
279 if (stream_info->map != (
char *) NULL)
280 stream_info->map=DestroyString(stream_info->map);
281 if (stream_info->pixels != (
unsigned char *) NULL)
282 stream_info->pixels=(
unsigned char *) RelinquishAlignedMemory(
283 stream_info->pixels);
284 if (stream_info->stream != (
Image *) NULL)
286 (void) CloseBlob(stream_info->stream);
287 stream_info->stream=DestroyImage(stream_info->stream);
289 if (stream_info->quantum_info != (
QuantumInfo *) NULL)
290 stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
291 stream_info->signature=(~MagickCoreSignature);
292 stream_info=(
StreamInfo *) RelinquishMagickMemory(stream_info);
320 static void *GetAuthenticMetacontentFromStream(
const Image *image)
325 assert(image != (
Image *) NULL);
326 assert(image->signature == MagickCoreSignature);
327 if (IsEventLogging() != MagickFalse)
328 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
330 assert(cache_info->signature == MagickCoreSignature);
331 return(cache_info->metacontent);
366 static Quantum *GetAuthenticPixelsStream(
Image *image,
const ssize_t x,
367 const ssize_t y,
const size_t columns,
const size_t rows,
373 assert(image != (
Image *) NULL);
374 assert(image->signature == MagickCoreSignature);
375 if (IsEventLogging() != MagickFalse)
376 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
377 pixels=QueueAuthenticPixelsStream(image,x,y,columns,rows,exception);
404 static Quantum *GetAuthenticPixelsFromStream(
const Image *image)
409 assert(image != (
Image *) NULL);
410 assert(image->signature == MagickCoreSignature);
411 if (IsEventLogging() != MagickFalse)
412 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
414 assert(cache_info->signature == MagickCoreSignature);
415 return(cache_info->pixels);
449 static MagickBooleanType GetOneAuthenticPixelFromStream(
Image *image,
450 const ssize_t x,
const ssize_t y,Quantum *pixel,
ExceptionInfo *exception)
458 assert(image != (
Image *) NULL);
459 assert(image->signature == MagickCoreSignature);
460 (void) memset(pixel,0,MaxPixelChannels*
sizeof(*pixel));
461 p=GetAuthenticPixelsStream(image,x,y,1,1,exception);
462 if (p == (Quantum *) NULL)
464 pixel[RedPixelChannel]=ClampToQuantum(image->background_color.red);
465 pixel[GreenPixelChannel]=ClampToQuantum(image->background_color.green);
466 pixel[BluePixelChannel]=ClampToQuantum(image->background_color.blue);
467 pixel[BlackPixelChannel]=ClampToQuantum(image->background_color.black);
468 pixel[AlphaPixelChannel]=ClampToQuantum(image->background_color.alpha);
471 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
473 PixelChannel channel = GetPixelChannelChannel(image,i);
512 static MagickBooleanType GetOneVirtualPixelFromStream(
const Image *image,
513 const VirtualPixelMethod virtual_pixel_method,
const ssize_t x,
const ssize_t y,
522 assert(image != (
Image *) NULL);
523 assert(image->signature == MagickCoreSignature);
524 (void) memset(pixel,0,MaxPixelChannels*
sizeof(*pixel));
525 p=GetVirtualPixelStream(image,virtual_pixel_method,x,y,1,1,exception);
526 if (p == (
const Quantum *) NULL)
528 pixel[RedPixelChannel]=ClampToQuantum(image->background_color.red);
529 pixel[GreenPixelChannel]=ClampToQuantum(image->background_color.green);
530 pixel[BluePixelChannel]=ClampToQuantum(image->background_color.blue);
531 pixel[BlackPixelChannel]=ClampToQuantum(image->background_color.black);
532 pixel[AlphaPixelChannel]=ClampToQuantum(image->background_color.alpha);
535 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
537 PixelChannel channel = GetPixelChannelChannel(image,i);
565 MagickPrivate
const void *GetStreamInfoClientData(
StreamInfo *stream_info)
568 assert(stream_info->signature == MagickCoreSignature);
569 return(stream_info->client_data);
598 static const Quantum *GetVirtualPixelsStream(
const Image *image)
603 assert(image != (
Image *) NULL);
604 assert(image->signature == MagickCoreSignature);
605 if (IsEventLogging() != MagickFalse)
606 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
608 assert(cache_info->signature == MagickCoreSignature);
609 return(cache_info->pixels);
636 static const void *GetVirtualMetacontentFromStream(
const Image *image)
641 assert(image != (
Image *) NULL);
642 assert(image->signature == MagickCoreSignature);
643 if (IsEventLogging() != MagickFalse)
644 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
646 assert(cache_info->signature == MagickCoreSignature);
647 return(cache_info->metacontent);
686 static inline MagickBooleanType AcquireStreamPixels(
CacheInfo *cache_info,
689 if (cache_info->length != (MagickSizeType) ((
size_t) cache_info->length))
691 cache_info->pixels=(Quantum *) MagickAssumeAligned(AcquireAlignedMemory(1,
692 (
size_t) cache_info->length));
693 if (cache_info->pixels != (Quantum *) NULL)
694 (
void) memset(cache_info->pixels,0,(
size_t) cache_info->length);
697 (void) ThrowMagickException(exception,GetMagickModule(),
698 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",
699 cache_info->filename);
705 static const Quantum *GetVirtualPixelStream(
const Image *image,
706 const VirtualPixelMethod magick_unused(virtual_pixel_method),
const ssize_t x,
707 const ssize_t y,
const size_t columns,
const size_t rows,
722 magick_unreferenced(virtual_pixel_method);
727 assert(image != (
const Image *) NULL);
728 assert(image->signature == MagickCoreSignature);
729 if (IsEventLogging() != MagickFalse)
730 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
731 if ((x < 0) || (y < 0) ||
732 ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
733 ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
734 (columns == 0) || (rows == 0))
736 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
737 "ImageDoesNotContainTheStreamGeometry",
"`%s'",image->filename);
738 return((Quantum *) NULL);
741 assert(cache_info->signature == MagickCoreSignature);
745 number_pixels=(MagickSizeType) columns*rows;
746 length=(size_t) number_pixels*cache_info->number_channels*
sizeof(Quantum);
747 if (cache_info->number_channels == 0)
748 length=(size_t) number_pixels*
sizeof(Quantum);
749 if (cache_info->metacontent_extent != 0)
750 length+=number_pixels*cache_info->metacontent_extent;
751 if (cache_info->pixels == (Quantum *) NULL)
753 cache_info->length=length;
754 status=AcquireStreamPixels(cache_info,exception);
755 if (status == MagickFalse)
757 cache_info->length=0;
758 return((Quantum *) NULL);
762 if (cache_info->length < length)
764 RelinquishStreamPixels(cache_info);
765 cache_info->length=length;
766 status=AcquireStreamPixels(cache_info,exception);
767 if (status == MagickFalse)
769 cache_info->length=0;
770 return((Quantum *) NULL);
773 cache_info->metacontent=(
void *) NULL;
774 if (cache_info->metacontent_extent != 0)
775 cache_info->metacontent=(
void *) (cache_info->pixels+number_pixels*
776 cache_info->number_channels);
777 return(cache_info->pixels);
809 MagickExport MagickBooleanType OpenStream(
const ImageInfo *image_info,
815 (void) CopyMagickString(stream_info->stream->filename,filename,
817 status=OpenBlob(image_info,stream_info->stream,WriteBinaryBlobMode,exception);
853 static inline MagickBooleanType ValidatePixelCacheMorphology(
854 const Image *magick_restrict image)
857 *magick_restrict cache_info;
867 p=image->channel_map;
868 q=cache_info->channel_map;
869 if ((image->storage_class != cache_info->storage_class) ||
870 (image->colorspace != cache_info->colorspace) ||
871 (image->alpha_trait != cache_info->alpha_trait) ||
872 (image->channels != cache_info->channels) ||
873 (image->columns != cache_info->columns) ||
874 (image->rows != cache_info->rows) ||
875 (image->number_channels != cache_info->number_channels) ||
876 (memcmp(p,q,image->number_channels*
sizeof(*p)) != 0) ||
877 (image->metacontent_extent != cache_info->metacontent_extent) ||
878 (cache_info->nexus_info == (
NexusInfo **) NULL))
883 static Quantum *QueueAuthenticPixelsStream(
Image *image,
const ssize_t x,
884 const ssize_t y,
const size_t columns,
const size_t rows,
905 assert(image != (
Image *) NULL);
906 if ((x < 0) || (y < 0) ||
907 ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
908 ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
909 (columns == 0) || (rows == 0))
911 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
912 "ImageDoesNotContainTheStreamGeometry",
"`%s'",image->filename);
913 return((Quantum *) NULL);
915 stream_handler=GetBlobStreamHandler(image);
916 if (stream_handler == (StreamHandler) NULL)
918 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
919 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
920 return((Quantum *) NULL);
923 assert(cache_info->signature == MagickCoreSignature);
924 if (ValidatePixelCacheMorphology(image) == MagickFalse)
926 if (cache_info->storage_class == UndefinedClass)
927 (void) stream_handler(image,(
const void *) NULL,(size_t)
928 cache_info->columns);
929 cache_info->storage_class=image->storage_class;
930 cache_info->colorspace=image->colorspace;
931 cache_info->alpha_trait=image->alpha_trait;
932 cache_info->channels=image->channels;
933 cache_info->columns=image->columns;
934 cache_info->rows=image->rows;
935 cache_info->number_channels=image->number_channels;
936 InitializePixelChannelMap(image);
937 ResetPixelCacheChannels(image);
938 image->cache=cache_info;
943 cache_info->columns=columns;
944 cache_info->rows=rows;
945 number_pixels=(MagickSizeType) columns*rows;
946 length=(size_t) number_pixels*cache_info->number_channels*
sizeof(Quantum);
947 if (cache_info->number_channels == 0)
948 length=(size_t) number_pixels*
sizeof(Quantum);
949 if (cache_info->metacontent_extent != 0)
950 length+=number_pixels*cache_info->metacontent_extent;
951 if (cache_info->pixels == (Quantum *) NULL)
953 cache_info->length=length;
954 status=AcquireStreamPixels(cache_info,exception);
955 if (status == MagickFalse)
957 cache_info->length=0;
958 return((Quantum *) NULL);
962 if (cache_info->length < length)
964 RelinquishStreamPixels(cache_info);
965 cache_info->length=length;
966 status=AcquireStreamPixels(cache_info,exception);
967 if (status == MagickFalse)
969 cache_info->length=0;
970 return((Quantum *) NULL);
973 cache_info->metacontent=(
void *) NULL;
974 if (cache_info->metacontent_extent != 0)
975 cache_info->metacontent=(
void *) (cache_info->pixels+number_pixels*
976 cache_info->number_channels);
977 return(cache_info->pixels);
1008 MagickExport
Image *ReadStream(
const ImageInfo *image_info,StreamHandler stream,
1023 assert(image_info != (
ImageInfo *) NULL);
1024 assert(image_info->signature == MagickCoreSignature);
1026 assert(exception->signature == MagickCoreSignature);
1027 if (IsEventLogging() != MagickFalse)
1028 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1029 image_info->filename);
1030 read_info=CloneImageInfo(image_info);
1031 read_info->cache=AcquirePixelCache(0);
1032 GetPixelCacheMethods(&cache_methods);
1033 cache_methods.get_virtual_pixel_handler=GetVirtualPixelStream;
1034 cache_methods.get_virtual_pixels_handler=GetVirtualPixelsStream;
1035 cache_methods.get_virtual_metacontent_from_handler=
1036 GetVirtualMetacontentFromStream;
1037 cache_methods.get_authentic_pixels_handler=GetAuthenticPixelsStream;
1038 cache_methods.queue_authentic_pixels_handler=QueueAuthenticPixelsStream;
1039 cache_methods.sync_authentic_pixels_handler=SyncAuthenticPixelsStream;
1040 cache_methods.get_authentic_pixels_from_handler=GetAuthenticPixelsFromStream;
1041 cache_methods.get_authentic_metacontent_from_handler=
1042 GetAuthenticMetacontentFromStream;
1043 cache_methods.get_one_virtual_pixel_from_handler=GetOneVirtualPixelFromStream;
1044 cache_methods.get_one_authentic_pixel_from_handler=
1045 GetOneAuthenticPixelFromStream;
1046 cache_methods.destroy_pixel_handler=DestroyPixelStream;
1047 SetPixelCacheMethods(read_info->cache,&cache_methods);
1048 read_info->stream=stream;
1049 image=ReadImage(read_info,exception);
1050 if (image != (
Image *) NULL)
1052 InitializePixelChannelMap(image);
1053 ResetPixelCacheChannels(image);
1055 read_info=DestroyImageInfo(read_info);
1077 MagickPrivate
void ResetStreamAnonymousMemory(
void)
1106 MagickPrivate
void SetStreamInfoClientData(
StreamInfo *stream_info,
1107 const void *client_data)
1110 assert(stream_info->signature == MagickCoreSignature);
1111 stream_info->client_data=client_data;
1138 MagickExport
void SetStreamInfoMap(
StreamInfo *stream_info,
const char *map)
1141 assert(stream_info->signature == MagickCoreSignature);
1142 (void) CloneString(&stream_info->map,map);
1170 MagickExport
void SetStreamInfoStorageType(
StreamInfo *stream_info,
1171 const StorageType storage_type)
1174 assert(stream_info->signature == MagickCoreSignature);
1175 stream_info->storage_type=storage_type;
1207 #if defined(__cplusplus) || defined(c_plusplus)
1211 static size_t WriteStreamImage(
const Image *image,
const void *pixels,
1212 const size_t columns)
1231 stream_info=(
StreamInfo *) image->client_data;
1232 switch (stream_info->storage_type)
1234 default: packet_size=
sizeof(
unsigned char);
break;
1235 case CharPixel: packet_size=
sizeof(
unsigned char);
break;
1236 case DoublePixel: packet_size=
sizeof(double);
break;
1237 case FloatPixel: packet_size=
sizeof(float);
break;
1238 case LongPixel: packet_size=
sizeof(
unsigned int);
break;
1239 case LongLongPixel: packet_size=
sizeof(MagickSizeType);
break;
1240 case QuantumPixel: packet_size=
sizeof(Quantum);
break;
1241 case ShortPixel: packet_size=
sizeof(
unsigned short);
break;
1244 assert(cache_info->signature == MagickCoreSignature);
1245 packet_size*=strlen(stream_info->map);
1246 length=packet_size*cache_info->columns*cache_info->rows;
1247 if (image != stream_info->image)
1255 (void) RelinquishAlignedMemory(stream_info->pixels);
1256 stream_info->pixels=(
unsigned char *) AcquireAlignedMemory(1,length);
1257 if (stream_info->pixels == (
unsigned char *) NULL)
1259 (void) memset(stream_info->pixels,0,length);
1260 stream_info->image=image;
1261 write_info=CloneImageInfo(stream_info->image_info);
1262 (void) SetImageInfo(write_info,1,stream_info->exception);
1263 if (write_info->extract != (
char *) NULL)
1264 (
void) ParseAbsoluteGeometry(write_info->extract,
1265 &stream_info->extract_info);
1267 write_info=DestroyImageInfo(write_info);
1269 extract_info=stream_info->extract_info;
1270 if ((extract_info.width == 0) || (extract_info.height == 0))
1275 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1276 count=WriteBlob(stream_info->stream,length,stream_info->pixels);
1278 return(count == 0 ? 0 : columns);
1280 if ((stream_info->y < extract_info.y) ||
1281 (stream_info->y >= (ssize_t) (extract_info.y+extract_info.height)))
1289 (void) StreamImagePixels(stream_info,image,stream_info->exception);
1290 length=packet_size*extract_info.width;
1291 count=WriteBlob(stream_info->stream,length,stream_info->pixels+packet_size*
1294 return(count == 0 ? 0 : columns);
1297 #if defined(__cplusplus) || defined(c_plusplus)
1310 assert(image_info != (
const ImageInfo *) NULL);
1311 assert(image_info->signature == MagickCoreSignature);
1313 assert(stream_info->signature == MagickCoreSignature);
1315 if (IsEventLogging() != MagickFalse)
1316 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1317 image_info->filename);
1318 read_info=CloneImageInfo(image_info);
1319 stream_info->image_info=image_info;
1320 stream_info->quantum_info=AcquireQuantumInfo(image_info,(
Image *) NULL);
1321 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1323 read_info=DestroyImageInfo(read_info);
1324 return((
Image *) NULL);
1326 stream_info->exception=exception;
1327 read_info->client_data=(
void *) stream_info;
1328 image=ReadStream(read_info,&WriteStreamImage,exception);
1329 read_info=DestroyImageInfo(read_info);
1330 stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
1331 stream_info->quantum_info=AcquireQuantumInfo(image_info,image);
1332 if (stream_info->quantum_info == (
QuantumInfo *) NULL)
1333 image=DestroyImage(image);
1366 static MagickBooleanType StreamImagePixels(
const StreamInfo *stream_info,
1386 assert(stream_info->signature == MagickCoreSignature);
1387 assert(image != (
Image *) NULL);
1388 assert(image->signature == MagickCoreSignature);
1389 if (IsEventLogging() != MagickFalse)
1390 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1391 length=strlen(stream_info->map);
1392 quantum_map=(QuantumType *) AcquireQuantumMemory(length,
sizeof(*quantum_map));
1393 if (quantum_map == (QuantumType *) NULL)
1395 (void) ThrowMagickException(exception,GetMagickModule(),
1396 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1397 return(MagickFalse);
1399 (void) memset(quantum_map,0,length*
sizeof(*quantum_map));
1400 for (i=0; i < (ssize_t) length; i++)
1402 switch (stream_info->map[i])
1407 quantum_map[i]=AlphaQuantum;
1413 quantum_map[i]=BlueQuantum;
1419 quantum_map[i]=CyanQuantum;
1420 if (image->colorspace == CMYKColorspace)
1422 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1423 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1424 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1425 return(MagickFalse);
1430 quantum_map[i]=GreenQuantum;
1436 quantum_map[i]=IndexQuantum;
1442 quantum_map[i]=BlackQuantum;
1443 if (image->colorspace == CMYKColorspace)
1445 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1446 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1447 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1448 return(MagickFalse);
1453 quantum_map[i]=MagentaQuantum;
1454 if (image->colorspace == CMYKColorspace)
1456 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1457 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1458 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1459 return(MagickFalse);
1464 quantum_map[i]=OpacityQuantum;
1470 quantum_map[i]=UndefinedQuantum;
1476 quantum_map[i]=RedQuantum;
1482 quantum_map[i]=YellowQuantum;
1483 if (image->colorspace == CMYKColorspace)
1485 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1486 (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1487 "ColorSeparatedImageRequired",
"`%s'",stream_info->map);
1488 return(MagickFalse);
1492 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1493 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
1494 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
1495 return(MagickFalse);
1499 quantum_info=stream_info->quantum_info;
1500 switch (stream_info->storage_type)
1507 q=(
unsigned char *) stream_info->pixels;
1508 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1510 p=GetAuthenticPixelQueue(image);
1511 if (p == (
const Quantum *) NULL)
1513 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1515 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1516 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1517 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1518 p+=GetPixelChannels(image);
1522 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1524 p=GetAuthenticPixelQueue(image);
1525 if (p == (
const Quantum *) NULL)
1527 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1529 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1530 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1531 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1532 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
1533 p+=GetPixelChannels(image);
1537 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1539 p=GetAuthenticPixelQueue(image);
1540 if (p == (
const Quantum *) NULL)
1542 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1544 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1545 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1546 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1547 *q++=ScaleQuantumToChar((Quantum) 0);
1548 p+=GetPixelChannels(image);
1552 if (LocaleCompare(stream_info->map,
"I") == 0)
1554 p=GetAuthenticPixelQueue(image);
1555 if (p == (
const Quantum *) NULL)
1557 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1559 *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1560 p+=GetPixelChannels(image);
1564 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1566 p=GetAuthenticPixelQueue(image);
1567 if (p == (
const Quantum *) NULL)
1569 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1571 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1572 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1573 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1574 p+=GetPixelChannels(image);
1578 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1580 p=GetAuthenticPixelQueue(image);
1581 if (p == (
const Quantum *) NULL)
1583 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1585 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1586 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1587 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1588 *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
1589 p+=GetPixelChannels(image);
1593 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1595 p=GetAuthenticPixelQueue(image);
1596 if (p == (
const Quantum *) NULL)
1598 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1600 *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1601 *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1602 *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1603 *q++=ScaleQuantumToChar((Quantum) 0);
1604 p+=GetPixelChannels(image);
1608 p=GetAuthenticPixelQueue(image);
1609 if (p == (
const Quantum *) NULL)
1611 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1613 for (i=0; i < (ssize_t) length; i++)
1616 switch (quantum_map[i])
1621 *q=ScaleQuantumToChar(GetPixelRed(image,p));
1625 case MagentaQuantum:
1627 *q=ScaleQuantumToChar(GetPixelGreen(image,p));
1633 *q=ScaleQuantumToChar(GetPixelBlue(image,p));
1638 *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
1641 case OpacityQuantum:
1643 *q=ScaleQuantumToChar(GetPixelOpacity(image,p));
1648 if (image->colorspace == CMYKColorspace)
1649 *q=ScaleQuantumToChar(GetPixelBlack(image,p));
1654 *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1662 p+=GetPixelChannels(image);
1671 q=(
double *) stream_info->pixels;
1672 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1674 p=GetAuthenticPixelQueue(image);
1675 if (p == (
const Quantum *) NULL)
1677 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1679 *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1680 quantum_info->scale+quantum_info->minimum);
1681 *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1682 quantum_info->scale+quantum_info->minimum);
1683 *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1684 quantum_info->scale+quantum_info->minimum);
1685 p+=GetPixelChannels(image);
1689 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1691 p=GetAuthenticPixelQueue(image);
1692 if (p == (
const Quantum *) NULL)
1694 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1696 *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1697 quantum_info->scale+quantum_info->minimum);
1698 *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1699 quantum_info->scale+quantum_info->minimum);
1700 *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1701 quantum_info->scale+quantum_info->minimum);
1702 *q++=(double) ((QuantumScale*GetPixelAlpha(image,p))*
1703 quantum_info->scale+quantum_info->minimum);
1704 p+=GetPixelChannels(image);
1708 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1710 p=GetAuthenticPixelQueue(image);
1711 if (p == (
const Quantum *) NULL)
1713 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1715 *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1716 quantum_info->scale+quantum_info->minimum);
1717 *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1718 quantum_info->scale+quantum_info->minimum);
1719 *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1720 quantum_info->scale+quantum_info->minimum);
1722 p+=GetPixelChannels(image);
1726 if (LocaleCompare(stream_info->map,
"I") == 0)
1728 p=GetAuthenticPixelQueue(image);
1729 if (p == (
const Quantum *) NULL)
1731 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1733 *q++=(double) ((QuantumScale*GetPixelIntensity(image,p))*
1734 quantum_info->scale+quantum_info->minimum);
1735 p+=GetPixelChannels(image);
1739 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1741 p=GetAuthenticPixelQueue(image);
1742 if (p == (
const Quantum *) NULL)
1744 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1746 *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1747 quantum_info->scale+quantum_info->minimum);
1748 *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1749 quantum_info->scale+quantum_info->minimum);
1750 *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1751 quantum_info->scale+quantum_info->minimum);
1752 p+=GetPixelChannels(image);
1756 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1758 p=GetAuthenticPixelQueue(image);
1759 if (p == (
const Quantum *) NULL)
1761 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1763 *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1764 quantum_info->scale+quantum_info->minimum);
1765 *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1766 quantum_info->scale+quantum_info->minimum);
1767 *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1768 quantum_info->scale+quantum_info->minimum);
1769 *q++=(double) ((QuantumScale*GetPixelAlpha(image,p))*
1770 quantum_info->scale+quantum_info->minimum);
1771 p+=GetPixelChannels(image);
1775 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1777 p=GetAuthenticPixelQueue(image);
1778 if (p == (
const Quantum *) NULL)
1780 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1782 *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1783 quantum_info->scale+quantum_info->minimum);
1784 *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1785 quantum_info->scale+quantum_info->minimum);
1786 *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1787 quantum_info->scale+quantum_info->minimum);
1789 p+=GetPixelChannels(image);
1793 p=GetAuthenticPixelQueue(image);
1794 if (p == (
const Quantum *) NULL)
1796 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1798 for (i=0; i < (ssize_t) length; i++)
1801 switch (quantum_map[i])
1806 *q=(double) ((QuantumScale*GetPixelRed(image,p))*
1807 quantum_info->scale+quantum_info->minimum);
1811 case MagentaQuantum:
1813 *q=(double) ((QuantumScale*GetPixelGreen(image,p))*
1814 quantum_info->scale+quantum_info->minimum);
1820 *q=(double) ((QuantumScale*GetPixelBlue(image,p))*
1821 quantum_info->scale+quantum_info->minimum);
1826 *q=(double) ((QuantumScale*GetPixelAlpha(image,p))*
1827 quantum_info->scale+quantum_info->minimum);
1830 case OpacityQuantum:
1832 *q=(double) ((QuantumScale*GetPixelOpacity(image,p))*
1833 quantum_info->scale+quantum_info->minimum);
1838 if (image->colorspace == CMYKColorspace)
1839 *q=(double) ((QuantumScale*GetPixelBlack(image,p))*
1840 quantum_info->scale+quantum_info->minimum);
1845 *q=(double) ((QuantumScale*GetPixelIntensity(image,p))*
1846 quantum_info->scale+quantum_info->minimum);
1854 p+=GetPixelChannels(image);
1863 q=(
float *) stream_info->pixels;
1864 if (LocaleCompare(stream_info->map,
"BGR") == 0)
1866 p=GetAuthenticPixelQueue(image);
1867 if (p == (
const Quantum *) NULL)
1869 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1871 *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1872 quantum_info->scale+quantum_info->minimum);
1873 *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1874 quantum_info->scale+quantum_info->minimum);
1875 *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1876 quantum_info->scale+quantum_info->minimum);
1877 p+=GetPixelChannels(image);
1881 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
1883 p=GetAuthenticPixelQueue(image);
1884 if (p == (
const Quantum *) NULL)
1886 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1888 *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1889 quantum_info->scale+quantum_info->minimum);
1890 *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1891 quantum_info->scale+quantum_info->minimum);
1892 *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1893 quantum_info->scale+quantum_info->minimum);
1894 *q++=(float) ((QuantumScale*GetPixelAlpha(image,p))*
1895 quantum_info->scale+quantum_info->minimum);
1896 p+=GetPixelChannels(image);
1900 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
1902 p=GetAuthenticPixelQueue(image);
1903 if (p == (
const Quantum *) NULL)
1905 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1907 *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1908 quantum_info->scale+quantum_info->minimum);
1909 *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1910 quantum_info->scale+quantum_info->minimum);
1911 *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1912 quantum_info->scale+quantum_info->minimum);
1914 p+=GetPixelChannels(image);
1918 if (LocaleCompare(stream_info->map,
"I") == 0)
1920 p=GetAuthenticPixelQueue(image);
1921 if (p == (
const Quantum *) NULL)
1923 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1925 *q++=(float) ((QuantumScale*GetPixelIntensity(image,p))*
1926 quantum_info->scale+quantum_info->minimum);
1927 p+=GetPixelChannels(image);
1931 if (LocaleCompare(stream_info->map,
"RGB") == 0)
1933 p=GetAuthenticPixelQueue(image);
1934 if (p == (
const Quantum *) NULL)
1936 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1938 *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1939 quantum_info->scale+quantum_info->minimum);
1940 *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1941 quantum_info->scale+quantum_info->minimum);
1942 *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1943 quantum_info->scale+quantum_info->minimum);
1944 p+=GetPixelChannels(image);
1948 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
1950 p=GetAuthenticPixelQueue(image);
1951 if (p == (
const Quantum *) NULL)
1953 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1955 *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1956 quantum_info->scale+quantum_info->minimum);
1957 *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1958 quantum_info->scale+quantum_info->minimum);
1959 *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1960 quantum_info->scale+quantum_info->minimum);
1961 *q++=(float) ((QuantumScale*GetPixelAlpha(image,p))*
1962 quantum_info->scale+quantum_info->minimum);
1963 p+=GetPixelChannels(image);
1967 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
1969 p=GetAuthenticPixelQueue(image);
1970 if (p == (
const Quantum *) NULL)
1972 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1974 *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1975 quantum_info->scale+quantum_info->minimum);
1976 *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1977 quantum_info->scale+quantum_info->minimum);
1978 *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1979 quantum_info->scale+quantum_info->minimum);
1981 p+=GetPixelChannels(image);
1985 p=GetAuthenticPixelQueue(image);
1986 if (p == (
const Quantum *) NULL)
1988 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1990 for (i=0; i < (ssize_t) length; i++)
1993 switch (quantum_map[i])
1998 *q=(float) ((QuantumScale*GetPixelRed(image,p))*
1999 quantum_info->scale+quantum_info->minimum);
2003 case MagentaQuantum:
2005 *q=(float) ((QuantumScale*GetPixelGreen(image,p))*
2006 quantum_info->scale+quantum_info->minimum);
2012 *q=(float) ((QuantumScale*GetPixelBlue(image,p))*
2013 quantum_info->scale+quantum_info->minimum);
2018 *q=(float) ((QuantumScale*GetPixelAlpha(image,p))*
2019 quantum_info->scale+quantum_info->minimum);
2022 case OpacityQuantum:
2024 *q=(float) ((QuantumScale*GetPixelOpacity(image,p))*
2025 quantum_info->scale+quantum_info->minimum);
2030 if (image->colorspace == CMYKColorspace)
2031 *q=(float) ((QuantumScale*GetPixelBlack(image,p))*
2032 quantum_info->scale+quantum_info->minimum);
2037 *q=(float) ((QuantumScale*GetPixelIntensity(image,p))*
2038 quantum_info->scale+quantum_info->minimum);
2046 p+=GetPixelChannels(image);
2055 q=(
unsigned int *) stream_info->pixels;
2056 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2058 p=GetAuthenticPixelQueue(image);
2059 if (p == (
const Quantum *) NULL)
2061 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2063 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2064 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2065 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2066 p+=GetPixelChannels(image);
2070 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2072 p=GetAuthenticPixelQueue(image);
2073 if (p == (
const Quantum *) NULL)
2075 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2077 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2078 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2079 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2080 *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
2081 p+=GetPixelChannels(image);
2085 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2087 p=GetAuthenticPixelQueue(image);
2088 if (p == (
const Quantum *) NULL)
2090 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2092 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2093 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2094 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2096 p+=GetPixelChannels(image);
2100 if (LocaleCompare(stream_info->map,
"I") == 0)
2102 p=GetAuthenticPixelQueue(image);
2103 if (p == (
const Quantum *) NULL)
2105 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2107 *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2108 p+=GetPixelChannels(image);
2112 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2114 p=GetAuthenticPixelQueue(image);
2115 if (p == (
const Quantum *) NULL)
2117 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2119 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2120 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2121 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2122 p+=GetPixelChannels(image);
2126 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2128 p=GetAuthenticPixelQueue(image);
2129 if (p == (
const Quantum *) NULL)
2131 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2133 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2134 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2135 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2136 *q++=ScaleQuantumToLong(GetPixelAlpha(image,p));
2137 p+=GetPixelChannels(image);
2141 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2143 p=GetAuthenticPixelQueue(image);
2144 if (p == (
const Quantum *) NULL)
2146 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2148 *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2149 *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2150 *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2152 p+=GetPixelChannels(image);
2156 p=GetAuthenticPixelQueue(image);
2157 if (p == (
const Quantum *) NULL)
2159 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2161 for (i=0; i < (ssize_t) length; i++)
2164 switch (quantum_map[i])
2169 *q=ScaleQuantumToLong(GetPixelRed(image,p));
2173 case MagentaQuantum:
2175 *q=ScaleQuantumToLong(GetPixelGreen(image,p));
2181 *q=ScaleQuantumToLong(GetPixelBlue(image,p));
2186 *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
2189 case OpacityQuantum:
2191 *q=ScaleQuantumToLong(GetPixelOpacity(image,p));
2196 if (image->colorspace == CMYKColorspace)
2197 *q=ScaleQuantumToLong(GetPixelBlack(image,p));
2202 *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2210 p+=GetPixelChannels(image);
2219 q=(MagickSizeType *) stream_info->pixels;
2220 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2222 p=GetAuthenticPixelQueue(image);
2223 if (p == (
const Quantum *) NULL)
2225 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2227 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2228 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2229 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2230 p+=GetPixelChannels(image);
2234 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2236 p=GetAuthenticPixelQueue(image);
2237 if (p == (
const Quantum *) NULL)
2239 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2241 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2242 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2243 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2244 *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2245 p+=GetPixelChannels(image);
2249 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2251 p=GetAuthenticPixelQueue(image);
2252 if (p == (
const Quantum *) NULL)
2254 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2256 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2257 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2258 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2260 p+=GetPixelChannels(image);
2264 if (LocaleCompare(stream_info->map,
"I") == 0)
2266 p=GetAuthenticPixelQueue(image);
2267 if (p == (
const Quantum *) NULL)
2269 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2271 *q++=ScaleQuantumToLongLong(ClampToQuantum(
2272 GetPixelIntensity(image,p)));
2273 p+=GetPixelChannels(image);
2277 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2279 p=GetAuthenticPixelQueue(image);
2280 if (p == (
const Quantum *) NULL)
2282 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2284 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2285 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2286 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2287 p+=GetPixelChannels(image);
2291 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2293 p=GetAuthenticPixelQueue(image);
2294 if (p == (
const Quantum *) NULL)
2296 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2298 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2299 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2300 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2301 *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2302 p+=GetPixelChannels(image);
2306 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2308 p=GetAuthenticPixelQueue(image);
2309 if (p == (
const Quantum *) NULL)
2311 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2313 *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2314 *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2315 *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2317 p+=GetPixelChannels(image);
2321 p=GetAuthenticPixelQueue(image);
2322 if (p == (
const Quantum *) NULL)
2324 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2326 for (i=0; i < (ssize_t) length; i++)
2329 switch (quantum_map[i])
2334 *q=ScaleQuantumToLongLong(GetPixelRed(image,p));
2338 case MagentaQuantum:
2340 *q=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2346 *q=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2351 *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2354 case OpacityQuantum:
2356 *q=ScaleQuantumToLongLong(GetPixelOpacity(image,p));
2361 if (image->colorspace == CMYKColorspace)
2362 *q=ScaleQuantumToLongLong(GetPixelBlack(image,p));
2367 *q=ScaleQuantumToLongLong(ClampToQuantum(
2368 GetPixelIntensity(image,p)));
2376 p+=GetPixelChannels(image);
2385 q=(Quantum *) stream_info->pixels;
2386 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2388 p=GetAuthenticPixelQueue(image);
2389 if (p == (
const Quantum *) NULL)
2391 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2393 *q++=GetPixelBlue(image,p);
2394 *q++=GetPixelGreen(image,p);
2395 *q++=GetPixelRed(image,p);
2396 p+=GetPixelChannels(image);
2400 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2402 p=GetAuthenticPixelQueue(image);
2403 if (p == (
const Quantum *) NULL)
2405 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2407 *q++=GetPixelBlue(image,p);
2408 *q++=GetPixelGreen(image,p);
2409 *q++=GetPixelRed(image,p);
2410 *q++=GetPixelAlpha(image,p);
2411 p+=GetPixelChannels(image);
2415 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2417 p=GetAuthenticPixelQueue(image);
2418 if (p == (
const Quantum *) NULL)
2420 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2422 *q++=GetPixelBlue(image,p);
2423 *q++=GetPixelGreen(image,p);
2424 *q++=GetPixelRed(image,p);
2426 p+=GetPixelChannels(image);
2430 if (LocaleCompare(stream_info->map,
"I") == 0)
2432 p=GetAuthenticPixelQueue(image);
2433 if (p == (
const Quantum *) NULL)
2435 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2437 *q++=ClampToQuantum(GetPixelIntensity(image,p));
2438 p+=GetPixelChannels(image);
2442 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2444 p=GetAuthenticPixelQueue(image);
2445 if (p == (
const Quantum *) NULL)
2447 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2449 *q++=GetPixelRed(image,p);
2450 *q++=GetPixelGreen(image,p);
2451 *q++=GetPixelBlue(image,p);
2452 p+=GetPixelChannels(image);
2456 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2458 p=GetAuthenticPixelQueue(image);
2459 if (p == (
const Quantum *) NULL)
2461 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2463 *q++=GetPixelRed(image,p);
2464 *q++=GetPixelGreen(image,p);
2465 *q++=GetPixelBlue(image,p);
2466 *q++=GetPixelAlpha(image,p);
2467 p+=GetPixelChannels(image);
2471 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2473 p=GetAuthenticPixelQueue(image);
2474 if (p == (
const Quantum *) NULL)
2476 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2478 *q++=GetPixelRed(image,p);
2479 *q++=GetPixelGreen(image,p);
2480 *q++=GetPixelBlue(image,p);
2482 p+=GetPixelChannels(image);
2486 p=GetAuthenticPixelQueue(image);
2487 if (p == (
const Quantum *) NULL)
2489 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2491 for (i=0; i < (ssize_t) length; i++)
2494 switch (quantum_map[i])
2499 *q=GetPixelRed(image,p);
2503 case MagentaQuantum:
2505 *q=GetPixelGreen(image,p);
2511 *q=GetPixelBlue(image,p);
2516 *q=GetPixelAlpha(image,p);
2519 case OpacityQuantum:
2521 *q=GetPixelOpacity(image,p);
2526 if (image->colorspace == CMYKColorspace)
2527 *q=GetPixelBlack(image,p);
2532 *q=ClampToQuantum(GetPixelIntensity(image,p));
2540 p+=GetPixelChannels(image);
2549 q=(
unsigned short *) stream_info->pixels;
2550 if (LocaleCompare(stream_info->map,
"BGR") == 0)
2552 p=GetAuthenticPixelQueue(image);
2553 if (p == (
const Quantum *) NULL)
2555 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2557 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2558 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2559 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2560 p+=GetPixelChannels(image);
2564 if (LocaleCompare(stream_info->map,
"BGRA") == 0)
2566 p=GetAuthenticPixelQueue(image);
2567 if (p == (
const Quantum *) NULL)
2569 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2571 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2572 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2573 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2574 *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
2575 p+=GetPixelChannels(image);
2579 if (LocaleCompare(stream_info->map,
"BGRP") == 0)
2581 p=GetAuthenticPixelQueue(image);
2582 if (p == (
const Quantum *) NULL)
2584 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2586 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2587 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2588 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2590 p+=GetPixelChannels(image);
2594 if (LocaleCompare(stream_info->map,
"I") == 0)
2596 p=GetAuthenticPixelQueue(image);
2597 if (p == (
const Quantum *) NULL)
2599 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2601 *q++=ScaleQuantumToShort(ClampToQuantum(
2602 GetPixelIntensity(image,p)));
2603 p+=GetPixelChannels(image);
2607 if (LocaleCompare(stream_info->map,
"RGB") == 0)
2609 p=GetAuthenticPixelQueue(image);
2610 if (p == (
const Quantum *) NULL)
2612 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2614 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2615 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2616 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2617 p+=GetPixelChannels(image);
2621 if (LocaleCompare(stream_info->map,
"RGBA") == 0)
2623 p=GetAuthenticPixelQueue(image);
2624 if (p == (
const Quantum *) NULL)
2626 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2628 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2629 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2630 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2631 *q++=ScaleQuantumToShort(GetPixelAlpha(image,p));
2632 p+=GetPixelChannels(image);
2636 if (LocaleCompare(stream_info->map,
"RGBP") == 0)
2638 p=GetAuthenticPixelQueue(image);
2639 if (p == (
const Quantum *) NULL)
2641 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2643 *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2644 *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2645 *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2647 p+=GetPixelChannels(image);
2651 p=GetAuthenticPixelQueue(image);
2652 if (p == (
const Quantum *) NULL)
2654 for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2656 for (i=0; i < (ssize_t) length; i++)
2659 switch (quantum_map[i])
2664 *q=ScaleQuantumToShort(GetPixelRed(image,p));
2668 case MagentaQuantum:
2670 *q=ScaleQuantumToShort(GetPixelGreen(image,p));
2676 *q=ScaleQuantumToShort(GetPixelBlue(image,p));
2681 *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
2684 case OpacityQuantum:
2686 *q=ScaleQuantumToShort(GetPixelOpacity(image,p));
2691 if (image->colorspace == CMYKColorspace)
2692 *q=ScaleQuantumToShort(GetPixelBlack(image,p));
2697 *q=ScaleQuantumToShort(ClampToQuantum(
2698 GetPixelIntensity(image,p)));
2706 p+=GetPixelChannels(image);
2712 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2713 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
2714 "UnrecognizedPixelMap",
"`%s'",stream_info->map);
2718 quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2748 static MagickBooleanType SyncAuthenticPixelsStream(
Image *image,
2760 assert(image != (
Image *) NULL);
2761 assert(image->signature == MagickCoreSignature);
2762 if (IsEventLogging() != MagickFalse)
2763 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2765 assert(cache_info->signature == MagickCoreSignature);
2766 stream_handler=GetBlobStreamHandler(image);
2767 if (stream_handler == (StreamHandler) NULL)
2769 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
2770 "NoStreamHandlerIsDefined",
"`%s'",image->filename);
2771 return(MagickFalse);
2773 length=stream_handler(image,cache_info->pixels,(
size_t) cache_info->columns);
2774 return(length == cache_info->columns ? MagickTrue : MagickFalse);
2805 MagickExport MagickBooleanType WriteStream(
const ImageInfo *image_info,
2814 assert(image_info != (
ImageInfo *) NULL);
2815 assert(image_info->signature == MagickCoreSignature);
2816 if (IsEventLogging() != MagickFalse)
2817 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2818 image_info->filename);
2819 assert(image != (
Image *) NULL);
2820 assert(image->signature == MagickCoreSignature);
2821 write_info=CloneImageInfo(image_info);
2822 *write_info->magick=
'\0';
2823 write_info->stream=stream;
2824 status=WriteImage(write_info,image,exception);
2825 write_info=DestroyImageInfo(write_info);