MagickCore  7.0.8
Convert, Edit, Or Compose Bitmap Images
stream.c
Go to the documentation of this file.
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % SSSSS TTTTT RRRR EEEEE AAA M M %
7 % SS T R R E A A MM MM %
8 % SSS T RRRR EEE AAAAA M M M %
9 % SS T R R E A A M M %
10 % SSSSS T R R EEEEE A A M M %
11 % %
12 % %
13 % MagickCore Pixel Stream Methods %
14 % %
15 % Software Design %
16 % Cristy %
17 % March 2000 %
18 % %
19 % %
20 % Copyright 1999-2018 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
22 % %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
25 % %
26 % https://imagemagick.org/script/license.php %
27 % %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
33 % %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35 %
36 %
37 %
38 */
39 
40 /*
41  Include declarations.
42 */
43 #include "MagickCore/studio.h"
44 #include "MagickCore/blob.h"
46 #include "MagickCore/cache.h"
50 #include "MagickCore/constitute.h"
51 #include "MagickCore/exception.h"
53 #include "MagickCore/geometry.h"
54 #include "MagickCore/memory_.h"
56 #include "MagickCore/pixel.h"
58 #include "MagickCore/policy.h"
59 #include "MagickCore/quantum.h"
61 #include "MagickCore/semaphore.h"
62 #include "MagickCore/stream.h"
64 #include "MagickCore/string_.h"
65 
66 /*
67  Typedef declaractions.
68 */
70 {
71  const ImageInfo
73 
74  const Image
76 
77  Image
79 
82 
83  char
84  *map;
85 
88 
89  unsigned char
91 
94 
95  ssize_t
96  y;
97 
100 
101  const void
103 
104  size_t
106 };
107 
108 /*
109  Declare pixel cache interfaces.
110 */
111 #if defined(__cplusplus) || defined(c_plusplus)
112 extern "C" {
113 #endif
114 
115 static const Quantum
116  *GetVirtualPixelStream(const Image *,const VirtualPixelMethod,const ssize_t,
117  const ssize_t,const size_t,const size_t,ExceptionInfo *);
118 
119 static MagickBooleanType
120  StreamImagePixels(const StreamInfo *,const Image *,ExceptionInfo *),
122 
123 static Quantum
124  *QueueAuthenticPixelsStream(Image *,const ssize_t,const ssize_t,const size_t,
125  const size_t,ExceptionInfo *);
126 
127 #if defined(__cplusplus) || defined(c_plusplus)
128 }
129 #endif
130 
131 static ssize_t
133 
134 /*
135 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
136 % %
137 % %
138 % %
139 + A c q u i r e S t r e a m I n f o %
140 % %
141 % %
142 % %
143 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
144 %
145 % AcquireStreamInfo() allocates the StreamInfo structure.
146 %
147 % The format of the AcquireStreamInfo method is:
148 %
149 % StreamInfo *AcquireStreamInfo(const ImageInfo *image_info,
150 % ExceptionInfo *exception)
151 %
152 % A description of each parameter follows:
153 %
154 % o image_info: the image info.
155 %
156 % o exception: return any errors or warnings in this structure.
157 %
158 */
160  ExceptionInfo *exception)
161 {
162  StreamInfo
163  *stream_info;
164 
165  stream_info=(StreamInfo *) AcquireCriticalMemory(sizeof(*stream_info));
166  (void) memset(stream_info,0,sizeof(*stream_info));
167  stream_info->pixels=(unsigned char *) MagickAssumeAligned(
168  AcquireAlignedMemory(1,sizeof(*stream_info->pixels)));
169  if (stream_info->pixels == (unsigned char *) NULL)
170  ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
171  stream_info->map=ConstantString("RGB");
172  stream_info->storage_type=CharPixel;
173  stream_info->stream=AcquireImage(image_info,exception);
174  stream_info->signature=MagickCoreSignature;
175  return(stream_info);
176 }
177 
178 /*
179 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
180 % %
181 % %
182 % %
183 + D e s t r o y P i x e l S t r e a m %
184 % %
185 % %
186 % %
187 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
188 %
189 % DestroyPixelStream() deallocates memory associated with the pixel stream.
190 %
191 % The format of the DestroyPixelStream() method is:
192 %
193 % void DestroyPixelStream(Image *image)
194 %
195 % A description of each parameter follows:
196 %
197 % o image: the image.
198 %
199 */
200 
201 static inline void RelinquishStreamPixels(CacheInfo *cache_info)
202 {
203  assert(cache_info != (CacheInfo *) NULL);
204  if (cache_info->mapped == MagickFalse)
205  (void) RelinquishAlignedMemory(cache_info->pixels);
206  else
207  (void) UnmapBlob(cache_info->pixels,(size_t) cache_info->length);
208  cache_info->pixels=(Quantum *) NULL;
209  cache_info->metacontent=(void *) NULL;
210  cache_info->length=0;
211  cache_info->mapped=MagickFalse;
212 }
213 
214 static void DestroyPixelStream(Image *image)
215 {
216  CacheInfo
217  *cache_info;
218 
220  destroy;
221 
222  assert(image != (Image *) NULL);
223  assert(image->signature == MagickCoreSignature);
224  if (image->debug != MagickFalse)
225  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
226  cache_info=(CacheInfo *) image->cache;
227  assert(cache_info->signature == MagickCoreSignature);
228  destroy=MagickFalse;
229  LockSemaphoreInfo(cache_info->semaphore);
230  cache_info->reference_count--;
231  if (cache_info->reference_count == 0)
232  destroy=MagickTrue;
233  UnlockSemaphoreInfo(cache_info->semaphore);
234  if (destroy == MagickFalse)
235  return;
236  RelinquishStreamPixels(cache_info);
237  if (cache_info->nexus_info != (NexusInfo **) NULL)
238  cache_info->nexus_info=DestroyPixelCacheNexus(cache_info->nexus_info,
239  cache_info->number_threads);
240  if (cache_info->file_semaphore != (SemaphoreInfo *) NULL)
242  if (cache_info->semaphore != (SemaphoreInfo *) NULL)
243  RelinquishSemaphoreInfo(&cache_info->semaphore);
244  cache_info=(CacheInfo *) RelinquishMagickMemory(cache_info);
245 }
246 
247 /*
248 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
249 % %
250 % %
251 % %
252 + D e s t r o y S t r e a m I n f o %
253 % %
254 % %
255 % %
256 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
257 %
258 % DestroyStreamInfo() destroys memory associated with the StreamInfo
259 % structure.
260 %
261 % The format of the DestroyStreamInfo method is:
262 %
263 % StreamInfo *DestroyStreamInfo(StreamInfo *stream_info)
264 %
265 % A description of each parameter follows:
266 %
267 % o stream_info: the stream info.
268 %
269 */
271 {
272  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
273  assert(stream_info != (StreamInfo *) NULL);
274  assert(stream_info->signature == MagickCoreSignature);
275  if (stream_info->map != (char *) NULL)
276  stream_info->map=DestroyString(stream_info->map);
277  if (stream_info->pixels != (unsigned char *) NULL)
278  stream_info->pixels=(unsigned char *) RelinquishAlignedMemory(
279  stream_info->pixels);
280  if (stream_info->stream != (Image *) NULL)
281  {
282  (void) CloseBlob(stream_info->stream);
283  stream_info->stream=DestroyImage(stream_info->stream);
284  }
285  if (stream_info->quantum_info != (QuantumInfo *) NULL)
286  stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
287  stream_info->signature=(~MagickCoreSignature);
288  stream_info=(StreamInfo *) RelinquishMagickMemory(stream_info);
289  return(stream_info);
290 }
291 
292 /*
293 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
294 % %
295 % %
296 % %
297 + G e t A u t h e n t i c M e t a c o n t e n t F r o m S t r e a m %
298 % %
299 % %
300 % %
301 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
302 %
303 % GetAuthenticMetacontentFromStream() returns the metacontent corresponding
304 % with the last call to QueueAuthenticPixelsStream() or
305 % GetAuthenticPixelsStream().
306 %
307 % The format of the GetAuthenticMetacontentFromStream() method is:
308 %
309 % void *GetAuthenticMetacontentFromStream(const Image *image)
310 %
311 % A description of each parameter follows:
312 %
313 % o image: the image.
314 %
315 */
316 static void *GetAuthenticMetacontentFromStream(const Image *image)
317 {
318  CacheInfo
319  *cache_info;
320 
321  assert(image != (Image *) NULL);
322  assert(image->signature == MagickCoreSignature);
323  if (image->debug != MagickFalse)
324  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
325  cache_info=(CacheInfo *) image->cache;
326  assert(cache_info->signature == MagickCoreSignature);
327  return(cache_info->metacontent);
328 }
329 
330 /*
331 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
332 % %
333 % %
334 % %
335 + G e t A u t h e n t i c P i x e l S t r e a m %
336 % %
337 % %
338 % %
339 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
340 %
341 % GetAuthenticPixelsStream() gets pixels from the in-memory or disk pixel
342 % cache as defined by the geometry parameters. A pointer to the pixels is
343 % returned if the pixels are transferred, otherwise a NULL is returned. For
344 % streams this method is a no-op.
345 %
346 % The format of the GetAuthenticPixelsStream() method is:
347 %
348 % Quantum *GetAuthenticPixelsStream(Image *image,const ssize_t x,
349 % const ssize_t y,const size_t columns,const size_t rows,
350 % ExceptionInfo *exception)
351 %
352 % A description of each parameter follows:
353 %
354 % o image: the image.
355 %
356 % o x,y,columns,rows: These values define the perimeter of a region of
357 % pixels.
358 %
359 % o exception: return any errors or warnings in this structure.
360 %
361 */
362 static Quantum *GetAuthenticPixelsStream(Image *image,const ssize_t x,
363  const ssize_t y,const size_t columns,const size_t rows,
364  ExceptionInfo *exception)
365 {
366  Quantum
367  *pixels;
368 
369  assert(image != (Image *) NULL);
370  assert(image->signature == MagickCoreSignature);
371  if (image->debug != MagickFalse)
372  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
373  pixels=QueueAuthenticPixelsStream(image,x,y,columns,rows,exception);
374  return(pixels);
375 }
376 
377 /*
378 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
379 % %
380 % %
381 % %
382 + G e t A u t h e n t i c P i x e l F r o m S t e a m %
383 % %
384 % %
385 % %
386 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
387 %
388 % GetAuthenticPixelsFromStream() returns the pixels associated with the last
389 % call to QueueAuthenticPixelsStream() or GetAuthenticPixelsStream().
390 %
391 % The format of the GetAuthenticPixelsFromStream() method is:
392 %
393 % Quantum *GetAuthenticPixelsFromStream(const Image image)
394 %
395 % A description of each parameter follows:
396 %
397 % o image: the image.
398 %
399 */
401 {
402  CacheInfo
403  *cache_info;
404 
405  assert(image != (Image *) NULL);
406  assert(image->signature == MagickCoreSignature);
407  if (image->debug != MagickFalse)
408  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
409  cache_info=(CacheInfo *) image->cache;
410  assert(cache_info->signature == MagickCoreSignature);
411  return(cache_info->pixels);
412 }
413 
414 /*
415 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
416 % %
417 % %
418 % %
419 + G e t O n e A u t h e n t i c P i x e l F r o m S t r e a m %
420 % %
421 % %
422 % %
423 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
424 %
425 % GetOneAuthenticPixelFromStream() returns a single pixel at the specified
426 % (x,y) location. The image background color is returned if an error occurs.
427 %
428 % The format of the GetOneAuthenticPixelFromStream() method is:
429 %
430 % MagickBooleanType GetOneAuthenticPixelFromStream(const Image image,
431 % const ssize_t x,const ssize_t y,Quantum *pixel,
432 % ExceptionInfo *exception)
433 %
434 % A description of each parameter follows:
435 %
436 % o image: the image.
437 %
438 % o pixel: return a pixel at the specified (x,y) location.
439 %
440 % o x,y: These values define the location of the pixel to return.
441 %
442 % o exception: return any errors or warnings in this structure.
443 %
444 */
446  const ssize_t x,const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
447 {
448  register Quantum
449  *p;
450 
451  register ssize_t
452  i;
453 
454  assert(image != (Image *) NULL);
455  assert(image->signature == MagickCoreSignature);
456  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
457  p=GetAuthenticPixelsStream(image,x,y,1,1,exception);
458  if (p == (Quantum *) NULL)
459  {
465  return(MagickFalse);
466  }
467  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
468  {
469  PixelChannel channel = GetPixelChannelChannel(image,i);
470  pixel[channel]=p[i];
471  }
472  return(MagickTrue);
473 }
474 
475 /*
476 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
477 % %
478 % %
479 % %
480 + G e t O n e V i r t u a l P i x e l F r o m S t r e a m %
481 % %
482 % %
483 % %
484 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
485 %
486 % GetOneVirtualPixelFromStream() returns a single pixel at the specified
487 % (x.y) location. The image background color is returned if an error occurs.
488 %
489 % The format of the GetOneVirtualPixelFromStream() method is:
490 %
491 % MagickBooleanType GetOneVirtualPixelFromStream(const Image image,
492 % const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
493 % const ssize_t y,Quantum *pixel,ExceptionInfo *exception)
494 %
495 % A description of each parameter follows:
496 %
497 % o image: the image.
498 %
499 % o virtual_pixel_method: the virtual pixel method.
500 %
501 % o x,y: These values define the location of the pixel to return.
502 %
503 % o pixel: return a pixel at the specified (x,y) location.
504 %
505 % o exception: return any errors or warnings in this structure.
506 %
507 */
509  const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,
510  Quantum *pixel,ExceptionInfo *exception)
511 {
512  const Quantum
513  *p;
514 
515  register ssize_t
516  i;
517 
518  assert(image != (Image *) NULL);
519  assert(image->signature == MagickCoreSignature);
520  (void) memset(pixel,0,MaxPixelChannels*sizeof(*pixel));
521  p=GetVirtualPixelStream(image,virtual_pixel_method,x,y,1,1,exception);
522  if (p == (const Quantum *) NULL)
523  {
529  return(MagickFalse);
530  }
531  for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
532  {
533  PixelChannel channel = GetPixelChannelChannel(image,i);
534  pixel[channel]=p[i];
535  }
536  return(MagickTrue);
537 }
538 
539 /*
540 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
541 % %
542 % %
543 % %
544 + G e t S t r e a m I n f o C l i e n t D a t a %
545 % %
546 % %
547 % %
548 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
549 %
550 % GetStreamInfoClientData() gets the stream info client data.
551 %
552 % The format of the GetStreamInfoClientData method is:
553 %
554 % const void *GetStreamInfoClientData(StreamInfo *stream_info)
555 %
556 % A description of each parameter follows:
557 %
558 % o stream_info: the stream info.
559 %
560 */
562 {
563  assert(stream_info != (StreamInfo *) NULL);
564  assert(stream_info->signature == MagickCoreSignature);
565  return(stream_info->client_data);
566 }
567 
568 /*
569 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
570 % %
571 % %
572 % %
573 + G e t V i r t u a l P i x e l s F r o m S t r e a m %
574 % %
575 % %
576 % %
577 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
578 %
579 % GetVirtualPixelsStream() returns the pixels associated with the last call to
580 % QueueAuthenticPixelsStream() or GetVirtualPixelStream().
581 %
582 % The format of the GetVirtualPixelsStream() method is:
583 %
584 % const Quantum *GetVirtualPixelsStream(const Image *image)
585 %
586 % A description of each parameter follows:
587 %
588 % o pixels: return the pixels associated corresponding with the last call to
589 % QueueAuthenticPixelsStream() or GetVirtualPixelStream().
590 %
591 % o image: the image.
592 %
593 */
594 static const Quantum *GetVirtualPixelsStream(const Image *image)
595 {
596  CacheInfo
597  *cache_info;
598 
599  assert(image != (Image *) NULL);
600  assert(image->signature == MagickCoreSignature);
601  if (image->debug != MagickFalse)
602  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
603  cache_info=(CacheInfo *) image->cache;
604  assert(cache_info->signature == MagickCoreSignature);
605  return(cache_info->pixels);
606 }
607 
608 /*
609 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
610 % %
611 % %
612 % %
613 + G e t V i r t u a l I n d e x e s F r o m S t r e a m %
614 % %
615 % %
616 % %
617 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
618 %
619 % GetVirtualMetacontentFromStream() returns the associated pixel channels
620 % corresponding with the last call to QueueAuthenticPixelsStream() or
621 % GetVirtualPixelStream().
622 %
623 % The format of the GetVirtualMetacontentFromStream() method is:
624 %
625 % const void *GetVirtualMetacontentFromStream(const Image *image)
626 %
627 % A description of each parameter follows:
628 %
629 % o image: the image.
630 %
631 */
632 static const void *GetVirtualMetacontentFromStream(const Image *image)
633 {
634  CacheInfo
635  *cache_info;
636 
637  assert(image != (Image *) NULL);
638  assert(image->signature == MagickCoreSignature);
639  if (image->debug != MagickFalse)
640  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
641  cache_info=(CacheInfo *) image->cache;
642  assert(cache_info->signature == MagickCoreSignature);
643  return(cache_info->metacontent);
644 }
645 
646 /*
647 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
648 % %
649 % %
650 % %
651 + G e t V i r t u a l P i x e l S t r e a m %
652 % %
653 % %
654 % %
655 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
656 %
657 % GetVirtualPixelStream() gets pixels from the in-memory or disk pixel cache as
658 % defined by the geometry parameters. A pointer to the pixels is returned if
659 % the pixels are transferred, otherwise a NULL is returned. For streams this
660 % method is a no-op.
661 %
662 % The format of the GetVirtualPixelStream() method is:
663 %
664 % const Quantum *GetVirtualPixelStream(const Image *image,
665 % const VirtualPixelMethod virtual_pixel_method,const ssize_t x,
666 % const ssize_t y,const size_t columns,const size_t rows,
667 % ExceptionInfo *exception)
668 %
669 % A description of each parameter follows:
670 %
671 % o image: the image.
672 %
673 % o virtual_pixel_method: the virtual pixel method.
674 %
675 % o x,y,columns,rows: These values define the perimeter of a region of
676 % pixels.
677 %
678 % o exception: return any errors or warnings in this structure.
679 %
680 */
681 
683  ExceptionInfo *exception)
684 {
685  if (cache_info->length != (MagickSizeType) ((size_t) cache_info->length))
686  return(MagickFalse);
687  if (cache_anonymous_memory < 0)
688  {
689  char
690  *value;
691 
692  /*
693  Does the security policy require anonymous mapping for pixel cache?
694  */
696  value=GetPolicyValue("pixel-cache-memory");
697  if (value == (char *) NULL)
698  value=GetPolicyValue("cache:memory-map");
699  if (LocaleCompare(value,"anonymous") == 0)
700  {
701 #if defined(MAGICKCORE_HAVE_MMAP) && defined(MAP_ANONYMOUS)
703 #else
704  (void) ThrowMagickException(exception,GetMagickModule(),
705  MissingDelegateError,"DelegateLibrarySupportNotBuiltIn",
706  "'%s' (policy requires anonymous memory mapping)",
707  cache_info->filename);
708 #endif
709  }
710  value=DestroyString(value);
711  }
712  if (cache_anonymous_memory <= 0)
713  {
714  cache_info->mapped=MagickFalse;
715  cache_info->pixels=(Quantum *) MagickAssumeAligned(
716  AcquireAlignedMemory(1,(size_t) cache_info->length));
717  }
718  else
719  {
720  cache_info->mapped=MagickTrue;
721  cache_info->pixels=(Quantum *) MapBlob(-1,IOMode,0,(size_t)
722  cache_info->length);
723  }
724  if (cache_info->pixels == (Quantum *) NULL)
725  {
726  (void) ThrowMagickException(exception,GetMagickModule(),
727  ResourceLimitError,"MemoryAllocationFailed","`%s'",
728  cache_info->filename);
729  return(MagickFalse);
730  }
731  return(MagickTrue);
732 }
733 
734 static const Quantum *GetVirtualPixelStream(const Image *image,
735  const VirtualPixelMethod magick_unused(virtual_pixel_method),const ssize_t x,
736  const ssize_t y,const size_t columns,const size_t rows,
737  ExceptionInfo *exception)
738 {
739  CacheInfo
740  *cache_info;
741 
743  status;
744 
746  number_pixels;
747 
748  size_t
749  length;
750 
751  magick_unreferenced(virtual_pixel_method);
752 
753  /*
754  Validate pixel cache geometry.
755  */
756  assert(image != (const Image *) NULL);
757  assert(image->signature == MagickCoreSignature);
758  if (image->debug != MagickFalse)
759  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
760  if ((x < 0) || (y < 0) ||
761  ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
762  ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
763  (columns == 0) || (rows == 0))
764  {
766  "ImageDoesNotContainTheStreamGeometry","`%s'",image->filename);
767  return((Quantum *) NULL);
768  }
769  cache_info=(CacheInfo *) image->cache;
770  assert(cache_info->signature == MagickCoreSignature);
771  /*
772  Pixels are stored in a temporary buffer until they are synced to the cache.
773  */
774  number_pixels=(MagickSizeType) columns*rows;
775  length=(size_t) number_pixels*cache_info->number_channels*sizeof(Quantum);
776  if (cache_info->number_channels == 0)
777  length=(size_t) number_pixels*sizeof(Quantum);
778  if (cache_info->metacontent_extent != 0)
779  length+=number_pixels*cache_info->metacontent_extent;
780  if (cache_info->pixels == (Quantum *) NULL)
781  {
782  cache_info->length=length;
783  status=AcquireStreamPixels(cache_info,exception);
784  if (status == MagickFalse)
785  {
786  cache_info->length=0;
787  return((Quantum *) NULL);
788  }
789  }
790  else
791  if (cache_info->length < length)
792  {
793  RelinquishStreamPixels(cache_info);
794  cache_info->length=length;
795  status=AcquireStreamPixels(cache_info,exception);
796  if (status == MagickFalse)
797  {
798  cache_info->length=0;
799  return((Quantum *) NULL);
800  }
801  }
802  cache_info->metacontent=(void *) NULL;
803  if (cache_info->metacontent_extent != 0)
804  cache_info->metacontent=(void *) (cache_info->pixels+number_pixels*
805  cache_info->number_channels);
806  return(cache_info->pixels);
807 }
808 
809 /*
810 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
811 % %
812 % %
813 % %
814 + O p e n S t r e a m %
815 % %
816 % %
817 % %
818 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
819 %
820 % OpenStream() opens a stream for writing by the StreamImage() method.
821 %
822 % The format of the OpenStream method is:
823 %
824 % MagickBooleanType OpenStream(const ImageInfo *image_info,
825 % StreamInfo *stream_info,const char *filename,ExceptionInfo *exception)
826 %
827 % A description of each parameter follows:
828 %
829 % o image_info: the image info.
830 %
831 % o stream_info: the stream info.
832 %
833 % o filename: the stream filename.
834 %
835 % o exception: return any errors or warnings in this structure.
836 %
837 */
839  StreamInfo *stream_info,const char *filename,ExceptionInfo *exception)
840 {
842  status;
843 
844  (void) CopyMagickString(stream_info->stream->filename,filename,
846  status=OpenBlob(image_info,stream_info->stream,WriteBinaryBlobMode,exception);
847  return(status);
848 }
849 
850 /*
851 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
852 % %
853 % %
854 % %
855 + Q u e u e A u t h e n t i c P i x e l s S t r e a m %
856 % %
857 % %
858 % %
859 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
860 %
861 % QueueAuthenticPixelsStream() allocates an area to store image pixels as
862 % defined by the region rectangle and returns a pointer to the area. This
863 % area is subsequently transferred from the pixel cache with method
864 % SyncAuthenticPixelsStream(). A pointer to the pixels is returned if the
865 % pixels are transferred, otherwise a NULL is returned.
866 %
867 % The format of the QueueAuthenticPixelsStream() method is:
868 %
869 % Quantum *QueueAuthenticPixelsStream(Image *image,const ssize_t x,
870 % const ssize_t y,const size_t columns,const size_t rows,
871 % ExceptionInfo *exception)
872 %
873 % A description of each parameter follows:
874 %
875 % o image: the image.
876 %
877 % o x,y,columns,rows: These values define the perimeter of a region of
878 % pixels.
879 %
880 */
881 static Quantum *QueueAuthenticPixelsStream(Image *image,const ssize_t x,
882  const ssize_t y,const size_t columns,const size_t rows,
883  ExceptionInfo *exception)
884 {
885  CacheInfo
886  *cache_info;
887 
889  status;
890 
892  number_pixels;
893 
894  size_t
895  length;
896 
898  stream_handler;
899 
900  /*
901  Validate pixel cache geometry.
902  */
903  assert(image != (Image *) NULL);
904  if ((x < 0) || (y < 0) ||
905  ((x+(ssize_t) columns) > (ssize_t) image->columns) ||
906  ((y+(ssize_t) rows) > (ssize_t) image->rows) ||
907  (columns == 0) || (rows == 0))
908  {
910  "ImageDoesNotContainTheStreamGeometry","`%s'",image->filename);
911  return((Quantum *) NULL);
912  }
913  stream_handler=GetBlobStreamHandler(image);
914  if (stream_handler == (StreamHandler) NULL)
915  {
917  "NoStreamHandlerIsDefined","`%s'",image->filename);
918  return((Quantum *) NULL);
919  }
920  cache_info=(CacheInfo *) image->cache;
921  assert(cache_info->signature == MagickCoreSignature);
922  if ((image->storage_class != GetPixelCacheStorageClass(image->cache)) ||
923  (image->colorspace != GetPixelCacheColorspace(image->cache)))
924  {
926  (void) stream_handler(image,(const void *) NULL,(size_t)
927  cache_info->columns);
928  cache_info->storage_class=image->storage_class;
929  cache_info->colorspace=image->colorspace;
930  cache_info->columns=image->columns;
931  cache_info->rows=image->rows;
932  image->cache=cache_info;
933  }
934  /*
935  Pixels are stored in a temporary buffer until they are synced to the cache.
936  */
937  cache_info->columns=columns;
938  cache_info->rows=rows;
939  number_pixels=(MagickSizeType) columns*rows;
940  length=(size_t) number_pixels*cache_info->number_channels*sizeof(Quantum);
941  if (cache_info->number_channels == 0)
942  length=(size_t) number_pixels*sizeof(Quantum);
943  if (cache_info->metacontent_extent != 0)
944  length+=number_pixels*cache_info->metacontent_extent;
945  if (cache_info->pixels == (Quantum *) NULL)
946  {
947  cache_info->length=length;
948  status=AcquireStreamPixels(cache_info,exception);
949  if (status == MagickFalse)
950  {
951  cache_info->length=0;
952  return((Quantum *) NULL);
953  }
954  }
955  else
956  if (cache_info->length < length)
957  {
958  RelinquishStreamPixels(cache_info);
959  cache_info->length=length;
960  status=AcquireStreamPixels(cache_info,exception);
961  if (status == MagickFalse)
962  {
963  cache_info->length=0;
964  return((Quantum *) NULL);
965  }
966  }
967  cache_info->metacontent=(void *) NULL;
968  if (cache_info->metacontent_extent != 0)
969  cache_info->metacontent=(void *) (cache_info->pixels+number_pixels*
970  cache_info->number_channels);
971  return(cache_info->pixels);
972 }
973 
974 /*
975 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
976 % %
977 % %
978 % %
979 % R e a d S t r e a m %
980 % %
981 % %
982 % %
983 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
984 %
985 % ReadStream() makes the image pixels available to a user supplied callback
986 % method immediately upon reading a scanline with the ReadImage() method.
987 %
988 % The format of the ReadStream() method is:
989 %
990 % Image *ReadStream(const ImageInfo *image_info,StreamHandler stream,
991 % ExceptionInfo *exception)
992 %
993 % A description of each parameter follows:
994 %
995 % o image_info: the image info.
996 %
997 % o stream: a callback method.
998 %
999 % o exception: return any errors or warnings in this structure.
1000 %
1001 */
1003  ExceptionInfo *exception)
1004 {
1005  CacheMethods
1006  cache_methods;
1007 
1008  Image
1009  *image;
1010 
1011  ImageInfo
1012  *read_info;
1013 
1014  /*
1015  Stream image pixels.
1016  */
1017  assert(image_info != (ImageInfo *) NULL);
1018  assert(image_info->signature == MagickCoreSignature);
1019  if (image_info->debug != MagickFalse)
1021  image_info->filename);
1022  assert(exception != (ExceptionInfo *) NULL);
1023  assert(exception->signature == MagickCoreSignature);
1024  read_info=CloneImageInfo(image_info);
1025  read_info->cache=AcquirePixelCache(0);
1026  GetPixelCacheMethods(&cache_methods);
1041  SetPixelCacheMethods(read_info->cache,&cache_methods);
1042  read_info->stream=stream;
1043  image=ReadImage(read_info,exception);
1044  if (image != (Image *) NULL)
1045  {
1047  ResetPixelCacheChannels(image);
1048  }
1049  read_info=DestroyImageInfo(read_info);
1050  return(image);
1051 }
1052 
1053 /*
1054 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1055 % %
1056 % %
1057 % %
1058 + R e s e t S t r e a m A n o n y m o u s M e m o r y %
1059 % %
1060 % %
1061 % %
1062 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1063 %
1064 % ResetStreamAnonymousMemory() resets the anonymous_memory value.
1065 %
1066 % The format of the ResetStreamAnonymousMemory method is:
1067 %
1068 % void ResetStreamAnonymousMemory(void)
1069 %
1070 */
1072 {
1074 }
1075 
1076 /*
1077 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1078 % %
1079 % %
1080 % %
1081 + S e t S t r e a m I n f o C l i e n t D a t a %
1082 % %
1083 % %
1084 % %
1085 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1086 %
1087 % SetStreamInfoClientData() sets the stream info client data.
1088 %
1089 % The format of the SetStreamInfoClientData method is:
1090 %
1091 % void SetStreamInfoClientData(StreamInfo *stream_info,
1092 % const void *client_data)
1093 %
1094 % A description of each parameter follows:
1095 %
1096 % o stream_info: the stream info.
1097 %
1098 % o client_data: the client data.
1099 %
1100 */
1102  const void *client_data)
1103 {
1104  assert(stream_info != (StreamInfo *) NULL);
1105  assert(stream_info->signature == MagickCoreSignature);
1106  stream_info->client_data=client_data;
1107 }
1108 
1109 /*
1110 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1111 % %
1112 % %
1113 % %
1114 + S e t S t r e a m I n f o M a p %
1115 % %
1116 % %
1117 % %
1118 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1119 %
1120 % SetStreamInfoMap() sets the stream info map member.
1121 %
1122 % The format of the SetStreamInfoMap method is:
1123 %
1124 % void SetStreamInfoMap(StreamInfo *stream_info,const char *map)
1125 %
1126 % A description of each parameter follows:
1127 %
1128 % o stream_info: the stream info.
1129 %
1130 % o map: the map.
1131 %
1132 */
1133 MagickExport void SetStreamInfoMap(StreamInfo *stream_info,const char *map)
1134 {
1135  assert(stream_info != (StreamInfo *) NULL);
1136  assert(stream_info->signature == MagickCoreSignature);
1137  (void) CloneString(&stream_info->map,map);
1138 }
1139 
1140 /*
1141 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1142 % %
1143 % %
1144 % %
1145 + S e t S t r e a m I n f o S t o r a g e T y p e %
1146 % %
1147 % %
1148 % %
1149 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1150 %
1151 % SetStreamInfoStorageType() sets the stream info storage type member.
1152 %
1153 % The format of the SetStreamInfoStorageType method is:
1154 %
1155 % void SetStreamInfoStorageType(StreamInfo *stream_info,
1156 % const StoreageType *storage_type)
1157 %
1158 % A description of each parameter follows:
1159 %
1160 % o stream_info: the stream info.
1161 %
1162 % o storage_type: the storage type.
1163 %
1164 */
1166  const StorageType storage_type)
1167 {
1168  assert(stream_info != (StreamInfo *) NULL);
1169  assert(stream_info->signature == MagickCoreSignature);
1170  stream_info->storage_type=storage_type;
1171 }
1172 
1173 /*
1174 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1175 % %
1176 % %
1177 % %
1178 + S t r e a m I m a g e %
1179 % %
1180 % %
1181 % %
1182 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1183 %
1184 % StreamImage() streams pixels from an image and writes them in a user
1185 % defined format and storage type (e.g. RGBA as 8-bit unsigned char).
1186 %
1187 % The format of the StreamImage() method is:
1188 %
1189 % Image *StreamImage(const ImageInfo *image_info,
1190 % StreamInfo *stream_info,ExceptionInfo *exception)
1191 %
1192 % A description of each parameter follows:
1193 %
1194 % o image_info: the image info.
1195 %
1196 % o stream_info: the stream info.
1197 %
1198 % o exception: return any errors or warnings in this structure.
1199 %
1200 */
1201 
1202 #if defined(__cplusplus) || defined(c_plusplus)
1203 extern "C" {
1204 #endif
1205 
1206 static size_t WriteStreamImage(const Image *image,const void *pixels,
1207  const size_t columns)
1208 {
1209  CacheInfo
1210  *cache_info;
1211 
1213  extract_info;
1214 
1215  size_t
1216  length,
1217  packet_size;
1218 
1219  ssize_t
1220  count;
1221 
1222  StreamInfo
1223  *stream_info;
1224 
1225  (void) pixels;
1226  stream_info=(StreamInfo *) image->client_data;
1227  switch (stream_info->storage_type)
1228  {
1229  default: packet_size=sizeof(unsigned char); break;
1230  case CharPixel: packet_size=sizeof(unsigned char); break;
1231  case DoublePixel: packet_size=sizeof(double); break;
1232  case FloatPixel: packet_size=sizeof(float); break;
1233  case LongPixel: packet_size=sizeof(unsigned int); break;
1234  case LongLongPixel: packet_size=sizeof(MagickSizeType); break;
1235  case QuantumPixel: packet_size=sizeof(Quantum); break;
1236  case ShortPixel: packet_size=sizeof(unsigned short); break;
1237  }
1238  cache_info=(CacheInfo *) image->cache;
1239  assert(cache_info->signature == MagickCoreSignature);
1240  packet_size*=strlen(stream_info->map);
1241  length=packet_size*cache_info->columns*cache_info->rows;
1242  if (image != stream_info->image)
1243  {
1244  ImageInfo
1245  *write_info;
1246 
1247  /*
1248  Prepare stream for writing.
1249  */
1250  (void) RelinquishAlignedMemory(stream_info->pixels);
1251  stream_info->pixels=(unsigned char *) AcquireAlignedMemory(1,length);
1252  if (stream_info->pixels == (unsigned char *) NULL)
1253  return(0);
1254  (void) memset(stream_info->pixels,0,length);
1255  stream_info->image=image;
1256  write_info=CloneImageInfo(stream_info->image_info);
1257  (void) SetImageInfo(write_info,1,stream_info->exception);
1258  if (write_info->extract != (char *) NULL)
1259  (void) ParseAbsoluteGeometry(write_info->extract,
1260  &stream_info->extract_info);
1261  stream_info->y=0;
1262  write_info=DestroyImageInfo(write_info);
1263  }
1264  extract_info=stream_info->extract_info;
1265  if ((extract_info.width == 0) || (extract_info.height == 0))
1266  {
1267  /*
1268  Write all pixels to stream.
1269  */
1270  (void) StreamImagePixels(stream_info,image,stream_info->exception);
1271  count=WriteBlob(stream_info->stream,length,stream_info->pixels);
1272  stream_info->y++;
1273  return(count == 0 ? 0 : columns);
1274  }
1275  if ((stream_info->y < extract_info.y) ||
1276  (stream_info->y >= (ssize_t) (extract_info.y+extract_info.height)))
1277  {
1278  stream_info->y++;
1279  return(columns);
1280  }
1281  /*
1282  Write a portion of the pixel row to the stream.
1283  */
1284  (void) StreamImagePixels(stream_info,image,stream_info->exception);
1285  length=packet_size*extract_info.width;
1286  count=WriteBlob(stream_info->stream,length,stream_info->pixels+packet_size*
1287  extract_info.x);
1288  stream_info->y++;
1289  return(count == 0 ? 0 : columns);
1290 }
1291 
1292 #if defined(__cplusplus) || defined(c_plusplus)
1293 }
1294 #endif
1295 
1297  StreamInfo *stream_info,ExceptionInfo *exception)
1298 {
1299  Image
1300  *image;
1301 
1302  ImageInfo
1303  *read_info;
1304 
1305  assert(image_info != (const ImageInfo *) NULL);
1306  assert(image_info->signature == MagickCoreSignature);
1307  if (image_info->debug != MagickFalse)
1309  image_info->filename);
1310  assert(stream_info != (StreamInfo *) NULL);
1311  assert(stream_info->signature == MagickCoreSignature);
1312  assert(exception != (ExceptionInfo *) NULL);
1313  read_info=CloneImageInfo(image_info);
1314  stream_info->image_info=image_info;
1315  stream_info->quantum_info=AcquireQuantumInfo(image_info,(Image *) NULL);
1316  if (stream_info->quantum_info == (QuantumInfo *) NULL)
1317  {
1318  read_info=DestroyImageInfo(read_info);
1319  return((Image *) NULL);
1320  }
1321  stream_info->exception=exception;
1322  read_info->client_data=(void *) stream_info;
1323  image=ReadStream(read_info,&WriteStreamImage,exception);
1324  read_info=DestroyImageInfo(read_info);
1325  stream_info->quantum_info=DestroyQuantumInfo(stream_info->quantum_info);
1326  stream_info->quantum_info=AcquireQuantumInfo(image_info,image);
1327  if (stream_info->quantum_info == (QuantumInfo *) NULL)
1328  image=DestroyImage(image);
1329  return(image);
1330 }
1331 
1332 /*
1333 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1334 % %
1335 % %
1336 % %
1337 + S t r e a m I m a g e P i x e l s %
1338 % %
1339 % %
1340 % %
1341 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1342 %
1343 % StreamImagePixels() extracts pixel data from an image and returns it in the
1344 % stream_info->pixels structure in the format as defined by
1345 % stream_info->quantum_info->map and stream_info->quantum_info->storage_type.
1346 %
1347 % The format of the StreamImagePixels method is:
1348 %
1349 % MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
1350 % const Image *image,ExceptionInfo *exception)
1351 %
1352 % A description of each parameter follows:
1353 %
1354 % o stream_info: the stream info.
1355 %
1356 % o image: the image.
1357 %
1358 % o exception: return any errors or warnings in this structure.
1359 %
1360 */
1362  const Image *image,ExceptionInfo *exception)
1363 {
1364  QuantumInfo
1365  *quantum_info;
1366 
1367  QuantumType
1368  *quantum_map;
1369 
1370  register const Quantum
1371  *p;
1372 
1373  register ssize_t
1374  i,
1375  x;
1376 
1377  size_t
1378  length;
1379 
1380  assert(stream_info != (StreamInfo *) NULL);
1381  assert(stream_info->signature == MagickCoreSignature);
1382  assert(image != (Image *) NULL);
1383  assert(image->signature == MagickCoreSignature);
1384  if (image->debug != MagickFalse)
1385  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1386  length=strlen(stream_info->map);
1387  quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
1388  if (quantum_map == (QuantumType *) NULL)
1389  {
1390  (void) ThrowMagickException(exception,GetMagickModule(),
1391  ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
1392  return(MagickFalse);
1393  }
1394  (void) memset(quantum_map,0,length*sizeof(*quantum_map));
1395  for (i=0; i < (ssize_t) length; i++)
1396  {
1397  switch (stream_info->map[i])
1398  {
1399  case 'A':
1400  case 'a':
1401  {
1402  quantum_map[i]=AlphaQuantum;
1403  break;
1404  }
1405  case 'B':
1406  case 'b':
1407  {
1408  quantum_map[i]=BlueQuantum;
1409  break;
1410  }
1411  case 'C':
1412  case 'c':
1413  {
1414  quantum_map[i]=CyanQuantum;
1415  if (image->colorspace == CMYKColorspace)
1416  break;
1417  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1418  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1419  "ColorSeparatedImageRequired","`%s'",stream_info->map);
1420  return(MagickFalse);
1421  }
1422  case 'g':
1423  case 'G':
1424  {
1425  quantum_map[i]=GreenQuantum;
1426  break;
1427  }
1428  case 'I':
1429  case 'i':
1430  {
1431  quantum_map[i]=IndexQuantum;
1432  break;
1433  }
1434  case 'K':
1435  case 'k':
1436  {
1437  quantum_map[i]=BlackQuantum;
1438  if (image->colorspace == CMYKColorspace)
1439  break;
1440  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1441  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1442  "ColorSeparatedImageRequired","`%s'",stream_info->map);
1443  return(MagickFalse);
1444  }
1445  case 'M':
1446  case 'm':
1447  {
1448  quantum_map[i]=MagentaQuantum;
1449  if (image->colorspace == CMYKColorspace)
1450  break;
1451  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1452  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1453  "ColorSeparatedImageRequired","`%s'",stream_info->map);
1454  return(MagickFalse);
1455  }
1456  case 'o':
1457  case 'O':
1458  {
1459  quantum_map[i]=OpacityQuantum;
1460  break;
1461  }
1462  case 'P':
1463  case 'p':
1464  {
1465  quantum_map[i]=UndefinedQuantum;
1466  break;
1467  }
1468  case 'R':
1469  case 'r':
1470  {
1471  quantum_map[i]=RedQuantum;
1472  break;
1473  }
1474  case 'Y':
1475  case 'y':
1476  {
1477  quantum_map[i]=YellowQuantum;
1478  if (image->colorspace == CMYKColorspace)
1479  break;
1480  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1481  (void) ThrowMagickException(exception,GetMagickModule(),ImageError,
1482  "ColorSeparatedImageRequired","`%s'",stream_info->map);
1483  return(MagickFalse);
1484  }
1485  default:
1486  {
1487  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
1489  "UnrecognizedPixelMap","`%s'",stream_info->map);
1490  return(MagickFalse);
1491  }
1492  }
1493  }
1494  quantum_info=stream_info->quantum_info;
1495  switch (stream_info->storage_type)
1496  {
1497  case CharPixel:
1498  {
1499  register unsigned char
1500  *q;
1501 
1502  q=(unsigned char *) stream_info->pixels;
1503  if (LocaleCompare(stream_info->map,"BGR") == 0)
1504  {
1505  p=GetAuthenticPixelQueue(image);
1506  if (p == (const Quantum *) NULL)
1507  break;
1508  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1509  {
1510  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1511  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1512  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1513  p+=GetPixelChannels(image);
1514  }
1515  break;
1516  }
1517  if (LocaleCompare(stream_info->map,"BGRA") == 0)
1518  {
1519  p=GetAuthenticPixelQueue(image);
1520  if (p == (const Quantum *) NULL)
1521  break;
1522  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1523  {
1524  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1525  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1526  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1527  *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
1528  p+=GetPixelChannels(image);
1529  }
1530  break;
1531  }
1532  if (LocaleCompare(stream_info->map,"BGRP") == 0)
1533  {
1534  p=GetAuthenticPixelQueue(image);
1535  if (p == (const Quantum *) NULL)
1536  break;
1537  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1538  {
1539  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1540  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1541  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1542  *q++=ScaleQuantumToChar((Quantum) 0);
1543  p+=GetPixelChannels(image);
1544  }
1545  break;
1546  }
1547  if (LocaleCompare(stream_info->map,"I") == 0)
1548  {
1549  p=GetAuthenticPixelQueue(image);
1550  if (p == (const Quantum *) NULL)
1551  break;
1552  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1553  {
1554  *q++=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1555  p+=GetPixelChannels(image);
1556  }
1557  break;
1558  }
1559  if (LocaleCompare(stream_info->map,"RGB") == 0)
1560  {
1561  p=GetAuthenticPixelQueue(image);
1562  if (p == (const Quantum *) NULL)
1563  break;
1564  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1565  {
1566  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1567  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1568  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1569  p+=GetPixelChannels(image);
1570  }
1571  break;
1572  }
1573  if (LocaleCompare(stream_info->map,"RGBA") == 0)
1574  {
1575  p=GetAuthenticPixelQueue(image);
1576  if (p == (const Quantum *) NULL)
1577  break;
1578  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1579  {
1580  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1581  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1582  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1583  *q++=ScaleQuantumToChar((Quantum) (GetPixelAlpha(image,p)));
1584  p+=GetPixelChannels(image);
1585  }
1586  break;
1587  }
1588  if (LocaleCompare(stream_info->map,"RGBP") == 0)
1589  {
1590  p=GetAuthenticPixelQueue(image);
1591  if (p == (const Quantum *) NULL)
1592  break;
1593  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1594  {
1595  *q++=ScaleQuantumToChar(GetPixelRed(image,p));
1596  *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
1597  *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
1598  *q++=ScaleQuantumToChar((Quantum) 0);
1599  p+=GetPixelChannels(image);
1600  }
1601  break;
1602  }
1603  p=GetAuthenticPixelQueue(image);
1604  if (p == (const Quantum *) NULL)
1605  break;
1606  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1607  {
1608  for (i=0; i < (ssize_t) length; i++)
1609  {
1610  *q=0;
1611  switch (quantum_map[i])
1612  {
1613  case RedQuantum:
1614  case CyanQuantum:
1615  {
1616  *q=ScaleQuantumToChar(GetPixelRed(image,p));
1617  break;
1618  }
1619  case GreenQuantum:
1620  case MagentaQuantum:
1621  {
1622  *q=ScaleQuantumToChar(GetPixelGreen(image,p));
1623  break;
1624  }
1625  case BlueQuantum:
1626  case YellowQuantum:
1627  {
1628  *q=ScaleQuantumToChar(GetPixelBlue(image,p));
1629  break;
1630  }
1631  case AlphaQuantum:
1632  {
1633  *q=ScaleQuantumToChar((Quantum) (GetPixelAlpha(image,p)));
1634  break;
1635  }
1636  case OpacityQuantum:
1637  {
1638  *q=ScaleQuantumToChar(GetPixelAlpha(image,p));
1639  break;
1640  }
1641  case BlackQuantum:
1642  {
1643  if (image->colorspace == CMYKColorspace)
1644  *q=ScaleQuantumToChar(GetPixelBlack(image,p));
1645  break;
1646  }
1647  case IndexQuantum:
1648  {
1649  *q=ScaleQuantumToChar(ClampToQuantum(GetPixelIntensity(image,p)));
1650  break;
1651  }
1652  default:
1653  break;
1654  }
1655  q++;
1656  }
1657  p+=GetPixelChannels(image);
1658  }
1659  break;
1660  }
1661  case DoublePixel:
1662  {
1663  register double
1664  *q;
1665 
1666  q=(double *) stream_info->pixels;
1667  if (LocaleCompare(stream_info->map,"BGR") == 0)
1668  {
1669  p=GetAuthenticPixelQueue(image);
1670  if (p == (const Quantum *) NULL)
1671  break;
1672  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1673  {
1674  *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1675  quantum_info->scale+quantum_info->minimum);
1676  *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1677  quantum_info->scale+quantum_info->minimum);
1678  *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1679  quantum_info->scale+quantum_info->minimum);
1680  p+=GetPixelChannels(image);
1681  }
1682  break;
1683  }
1684  if (LocaleCompare(stream_info->map,"BGRA") == 0)
1685  {
1686  p=GetAuthenticPixelQueue(image);
1687  if (p == (const Quantum *) NULL)
1688  break;
1689  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1690  {
1691  *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1692  quantum_info->scale+quantum_info->minimum);
1693  *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1694  quantum_info->scale+quantum_info->minimum);
1695  *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1696  quantum_info->scale+quantum_info->minimum);
1697  *q++=(double) ((QuantumScale*GetPixelAlpha(image,p))*
1698  quantum_info->scale+quantum_info->minimum);
1699  p+=GetPixelChannels(image);
1700  }
1701  break;
1702  }
1703  if (LocaleCompare(stream_info->map,"BGRP") == 0)
1704  {
1705  p=GetAuthenticPixelQueue(image);
1706  if (p == (const Quantum *) NULL)
1707  break;
1708  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1709  {
1710  *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1711  quantum_info->scale+quantum_info->minimum);
1712  *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1713  quantum_info->scale+quantum_info->minimum);
1714  *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1715  quantum_info->scale+quantum_info->minimum);
1716  *q++=0.0;
1717  p+=GetPixelChannels(image);
1718  }
1719  break;
1720  }
1721  if (LocaleCompare(stream_info->map,"I") == 0)
1722  {
1723  p=GetAuthenticPixelQueue(image);
1724  if (p == (const Quantum *) NULL)
1725  break;
1726  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1727  {
1728  *q++=(double) ((QuantumScale*GetPixelIntensity(image,p))*
1729  quantum_info->scale+quantum_info->minimum);
1730  p+=GetPixelChannels(image);
1731  }
1732  break;
1733  }
1734  if (LocaleCompare(stream_info->map,"RGB") == 0)
1735  {
1736  p=GetAuthenticPixelQueue(image);
1737  if (p == (const Quantum *) NULL)
1738  break;
1739  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1740  {
1741  *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1742  quantum_info->scale+quantum_info->minimum);
1743  *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1744  quantum_info->scale+quantum_info->minimum);
1745  *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1746  quantum_info->scale+quantum_info->minimum);
1747  p+=GetPixelChannels(image);
1748  }
1749  break;
1750  }
1751  if (LocaleCompare(stream_info->map,"RGBA") == 0)
1752  {
1753  p=GetAuthenticPixelQueue(image);
1754  if (p == (const Quantum *) NULL)
1755  break;
1756  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1757  {
1758  *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1759  quantum_info->scale+quantum_info->minimum);
1760  *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1761  quantum_info->scale+quantum_info->minimum);
1762  *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1763  quantum_info->scale+quantum_info->minimum);
1764  *q++=(double) ((QuantumScale*GetPixelAlpha(image,p))*
1765  quantum_info->scale+quantum_info->minimum);
1766  p+=GetPixelChannels(image);
1767  }
1768  break;
1769  }
1770  if (LocaleCompare(stream_info->map,"RGBP") == 0)
1771  {
1772  p=GetAuthenticPixelQueue(image);
1773  if (p == (const Quantum *) NULL)
1774  break;
1775  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1776  {
1777  *q++=(double) ((QuantumScale*GetPixelRed(image,p))*
1778  quantum_info->scale+quantum_info->minimum);
1779  *q++=(double) ((QuantumScale*GetPixelGreen(image,p))*
1780  quantum_info->scale+quantum_info->minimum);
1781  *q++=(double) ((QuantumScale*GetPixelBlue(image,p))*
1782  quantum_info->scale+quantum_info->minimum);
1783  *q++=0.0;
1784  p+=GetPixelChannels(image);
1785  }
1786  break;
1787  }
1788  p=GetAuthenticPixelQueue(image);
1789  if (p == (const Quantum *) NULL)
1790  break;
1791  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1792  {
1793  for (i=0; i < (ssize_t) length; i++)
1794  {
1795  *q=0;
1796  switch (quantum_map[i])
1797  {
1798  case RedQuantum:
1799  case CyanQuantum:
1800  {
1801  *q=(double) ((QuantumScale*GetPixelRed(image,p))*
1802  quantum_info->scale+quantum_info->minimum);
1803  break;
1804  }
1805  case GreenQuantum:
1806  case MagentaQuantum:
1807  {
1808  *q=(double) ((QuantumScale*GetPixelGreen(image,p))*
1809  quantum_info->scale+quantum_info->minimum);
1810  break;
1811  }
1812  case BlueQuantum:
1813  case YellowQuantum:
1814  {
1815  *q=(double) ((QuantumScale*GetPixelBlue(image,p))*
1816  quantum_info->scale+quantum_info->minimum);
1817  break;
1818  }
1819  case AlphaQuantum:
1820  {
1821  *q=(double) ((QuantumScale*GetPixelAlpha(image,p))*
1822  quantum_info->scale+quantum_info->minimum);
1823  break;
1824  }
1825  case OpacityQuantum:
1826  {
1827  *q=(double) ((QuantumScale*GetPixelAlpha(image,p))*
1828  quantum_info->scale+quantum_info->minimum);
1829  break;
1830  }
1831  case BlackQuantum:
1832  {
1833  if (image->colorspace == CMYKColorspace)
1834  *q=(double) ((QuantumScale*GetPixelBlack(image,p))*
1835  quantum_info->scale+quantum_info->minimum);
1836  break;
1837  }
1838  case IndexQuantum:
1839  {
1840  *q=(double) ((QuantumScale*GetPixelIntensity(image,p))*
1841  quantum_info->scale+quantum_info->minimum);
1842  break;
1843  }
1844  default:
1845  *q=0;
1846  }
1847  q++;
1848  }
1849  p+=GetPixelChannels(image);
1850  }
1851  break;
1852  }
1853  case FloatPixel:
1854  {
1855  register float
1856  *q;
1857 
1858  q=(float *) stream_info->pixels;
1859  if (LocaleCompare(stream_info->map,"BGR") == 0)
1860  {
1861  p=GetAuthenticPixelQueue(image);
1862  if (p == (const Quantum *) NULL)
1863  break;
1864  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1865  {
1866  *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1867  quantum_info->scale+quantum_info->minimum);
1868  *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1869  quantum_info->scale+quantum_info->minimum);
1870  *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1871  quantum_info->scale+quantum_info->minimum);
1872  p+=GetPixelChannels(image);
1873  }
1874  break;
1875  }
1876  if (LocaleCompare(stream_info->map,"BGRA") == 0)
1877  {
1878  p=GetAuthenticPixelQueue(image);
1879  if (p == (const Quantum *) NULL)
1880  break;
1881  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1882  {
1883  *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1884  quantum_info->scale+quantum_info->minimum);
1885  *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1886  quantum_info->scale+quantum_info->minimum);
1887  *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1888  quantum_info->scale+quantum_info->minimum);
1889  *q++=(float) ((QuantumScale*(Quantum) (GetPixelAlpha(image,p)))*
1890  quantum_info->scale+quantum_info->minimum);
1891  p+=GetPixelChannels(image);
1892  }
1893  break;
1894  }
1895  if (LocaleCompare(stream_info->map,"BGRP") == 0)
1896  {
1897  p=GetAuthenticPixelQueue(image);
1898  if (p == (const Quantum *) NULL)
1899  break;
1900  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1901  {
1902  *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1903  quantum_info->scale+quantum_info->minimum);
1904  *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1905  quantum_info->scale+quantum_info->minimum);
1906  *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1907  quantum_info->scale+quantum_info->minimum);
1908  *q++=0.0;
1909  p+=GetPixelChannels(image);
1910  }
1911  break;
1912  }
1913  if (LocaleCompare(stream_info->map,"I") == 0)
1914  {
1915  p=GetAuthenticPixelQueue(image);
1916  if (p == (const Quantum *) NULL)
1917  break;
1918  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1919  {
1920  *q++=(float) ((QuantumScale*GetPixelIntensity(image,p))*
1921  quantum_info->scale+quantum_info->minimum);
1922  p+=GetPixelChannels(image);
1923  }
1924  break;
1925  }
1926  if (LocaleCompare(stream_info->map,"RGB") == 0)
1927  {
1928  p=GetAuthenticPixelQueue(image);
1929  if (p == (const Quantum *) NULL)
1930  break;
1931  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1932  {
1933  *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1934  quantum_info->scale+quantum_info->minimum);
1935  *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1936  quantum_info->scale+quantum_info->minimum);
1937  *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1938  quantum_info->scale+quantum_info->minimum);
1939  p+=GetPixelChannels(image);
1940  }
1941  break;
1942  }
1943  if (LocaleCompare(stream_info->map,"RGBA") == 0)
1944  {
1945  p=GetAuthenticPixelQueue(image);
1946  if (p == (const Quantum *) NULL)
1947  break;
1948  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1949  {
1950  *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1951  quantum_info->scale+quantum_info->minimum);
1952  *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1953  quantum_info->scale+quantum_info->minimum);
1954  *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1955  quantum_info->scale+quantum_info->minimum);
1956  *q++=(float) ((QuantumScale*GetPixelAlpha(image,p))*
1957  quantum_info->scale+quantum_info->minimum);
1958  p+=GetPixelChannels(image);
1959  }
1960  break;
1961  }
1962  if (LocaleCompare(stream_info->map,"RGBP") == 0)
1963  {
1964  p=GetAuthenticPixelQueue(image);
1965  if (p == (const Quantum *) NULL)
1966  break;
1967  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1968  {
1969  *q++=(float) ((QuantumScale*GetPixelRed(image,p))*
1970  quantum_info->scale+quantum_info->minimum);
1971  *q++=(float) ((QuantumScale*GetPixelGreen(image,p))*
1972  quantum_info->scale+quantum_info->minimum);
1973  *q++=(float) ((QuantumScale*GetPixelBlue(image,p))*
1974  quantum_info->scale+quantum_info->minimum);
1975  *q++=0.0;
1976  p+=GetPixelChannels(image);
1977  }
1978  break;
1979  }
1980  p=GetAuthenticPixelQueue(image);
1981  if (p == (const Quantum *) NULL)
1982  break;
1983  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
1984  {
1985  for (i=0; i < (ssize_t) length; i++)
1986  {
1987  *q=0;
1988  switch (quantum_map[i])
1989  {
1990  case RedQuantum:
1991  case CyanQuantum:
1992  {
1993  *q=(float) ((QuantumScale*GetPixelRed(image,p))*
1994  quantum_info->scale+quantum_info->minimum);
1995  break;
1996  }
1997  case GreenQuantum:
1998  case MagentaQuantum:
1999  {
2000  *q=(float) ((QuantumScale*GetPixelGreen(image,p))*
2001  quantum_info->scale+quantum_info->minimum);
2002  break;
2003  }
2004  case BlueQuantum:
2005  case YellowQuantum:
2006  {
2007  *q=(float) ((QuantumScale*GetPixelBlue(image,p))*
2008  quantum_info->scale+quantum_info->minimum);
2009  break;
2010  }
2011  case AlphaQuantum:
2012  {
2013  *q=(float) ((QuantumScale*GetPixelAlpha(image,p))*
2014  quantum_info->scale+quantum_info->minimum);
2015  break;
2016  }
2017  case OpacityQuantum:
2018  {
2019  *q=(float) ((QuantumScale*GetPixelAlpha(image,p))*
2020  quantum_info->scale+quantum_info->minimum);
2021  break;
2022  }
2023  case BlackQuantum:
2024  {
2025  if (image->colorspace == CMYKColorspace)
2026  *q=(float) ((QuantumScale*GetPixelBlack(image,p))*
2027  quantum_info->scale+quantum_info->minimum);
2028  break;
2029  }
2030  case IndexQuantum:
2031  {
2032  *q=(float) ((QuantumScale*GetPixelIntensity(image,p))*
2033  quantum_info->scale+quantum_info->minimum);
2034  break;
2035  }
2036  default:
2037  *q=0;
2038  }
2039  q++;
2040  }
2041  p+=GetPixelChannels(image);
2042  }
2043  break;
2044  }
2045  case LongPixel:
2046  {
2047  register unsigned int
2048  *q;
2049 
2050  q=(unsigned int *) stream_info->pixels;
2051  if (LocaleCompare(stream_info->map,"BGR") == 0)
2052  {
2053  p=GetAuthenticPixelQueue(image);
2054  if (p == (const Quantum *) NULL)
2055  break;
2056  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2057  {
2058  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2059  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2060  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2061  p+=GetPixelChannels(image);
2062  }
2063  break;
2064  }
2065  if (LocaleCompare(stream_info->map,"BGRA") == 0)
2066  {
2067  p=GetAuthenticPixelQueue(image);
2068  if (p == (const Quantum *) NULL)
2069  break;
2070  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2071  {
2072  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2073  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2074  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2075  *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
2076  p+=GetPixelChannels(image);
2077  }
2078  break;
2079  }
2080  if (LocaleCompare(stream_info->map,"BGRP") == 0)
2081  {
2082  p=GetAuthenticPixelQueue(image);
2083  if (p == (const Quantum *) NULL)
2084  break;
2085  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2086  {
2087  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2088  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2089  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2090  *q++=0;
2091  p+=GetPixelChannels(image);
2092  }
2093  break;
2094  }
2095  if (LocaleCompare(stream_info->map,"I") == 0)
2096  {
2097  p=GetAuthenticPixelQueue(image);
2098  if (p == (const Quantum *) NULL)
2099  break;
2100  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2101  {
2102  *q++=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2103  p+=GetPixelChannels(image);
2104  }
2105  break;
2106  }
2107  if (LocaleCompare(stream_info->map,"RGB") == 0)
2108  {
2109  p=GetAuthenticPixelQueue(image);
2110  if (p == (const Quantum *) NULL)
2111  break;
2112  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2113  {
2114  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2115  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2116  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2117  p+=GetPixelChannels(image);
2118  }
2119  break;
2120  }
2121  if (LocaleCompare(stream_info->map,"RGBA") == 0)
2122  {
2123  p=GetAuthenticPixelQueue(image);
2124  if (p == (const Quantum *) NULL)
2125  break;
2126  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2127  {
2128  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2129  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2130  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2131  *q++=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
2132  p+=GetPixelChannels(image);
2133  }
2134  break;
2135  }
2136  if (LocaleCompare(stream_info->map,"RGBP") == 0)
2137  {
2138  p=GetAuthenticPixelQueue(image);
2139  if (p == (const Quantum *) NULL)
2140  break;
2141  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2142  {
2143  *q++=ScaleQuantumToLong(GetPixelRed(image,p));
2144  *q++=ScaleQuantumToLong(GetPixelGreen(image,p));
2145  *q++=ScaleQuantumToLong(GetPixelBlue(image,p));
2146  *q++=0;
2147  p+=GetPixelChannels(image);
2148  }
2149  break;
2150  }
2151  p=GetAuthenticPixelQueue(image);
2152  if (p == (const Quantum *) NULL)
2153  break;
2154  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2155  {
2156  for (i=0; i < (ssize_t) length; i++)
2157  {
2158  *q=0;
2159  switch (quantum_map[i])
2160  {
2161  case RedQuantum:
2162  case CyanQuantum:
2163  {
2164  *q=ScaleQuantumToLong(GetPixelRed(image,p));
2165  break;
2166  }
2167  case GreenQuantum:
2168  case MagentaQuantum:
2169  {
2170  *q=ScaleQuantumToLong(GetPixelGreen(image,p));
2171  break;
2172  }
2173  case BlueQuantum:
2174  case YellowQuantum:
2175  {
2176  *q=ScaleQuantumToLong(GetPixelBlue(image,p));
2177  break;
2178  }
2179  case AlphaQuantum:
2180  {
2181  *q=ScaleQuantumToLong((Quantum) (GetPixelAlpha(image,p)));
2182  break;
2183  }
2184  case OpacityQuantum:
2185  {
2186  *q=ScaleQuantumToLong(GetPixelAlpha(image,p));
2187  break;
2188  }
2189  case BlackQuantum:
2190  {
2191  if (image->colorspace == CMYKColorspace)
2192  *q=ScaleQuantumToLong(GetPixelBlack(image,p));
2193  break;
2194  }
2195  case IndexQuantum:
2196  {
2197  *q=ScaleQuantumToLong(ClampToQuantum(GetPixelIntensity(image,p)));
2198  break;
2199  }
2200  default:
2201  break;
2202  }
2203  q++;
2204  }
2205  p+=GetPixelChannels(image);
2206  }
2207  break;
2208  }
2209  case LongLongPixel:
2210  {
2211  register MagickSizeType
2212  *q;
2213 
2214  q=(MagickSizeType *) stream_info->pixels;
2215  if (LocaleCompare(stream_info->map,"BGR") == 0)
2216  {
2217  p=GetAuthenticPixelQueue(image);
2218  if (p == (const Quantum *) NULL)
2219  break;
2220  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2221  {
2222  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2223  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2224  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2225  p+=GetPixelChannels(image);
2226  }
2227  break;
2228  }
2229  if (LocaleCompare(stream_info->map,"BGRA") == 0)
2230  {
2231  p=GetAuthenticPixelQueue(image);
2232  if (p == (const Quantum *) NULL)
2233  break;
2234  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2235  {
2236  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2237  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2238  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2239  *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2240  p+=GetPixelChannels(image);
2241  }
2242  break;
2243  }
2244  if (LocaleCompare(stream_info->map,"BGRP") == 0)
2245  {
2246  p=GetAuthenticPixelQueue(image);
2247  if (p == (const Quantum *) NULL)
2248  break;
2249  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2250  {
2251  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2252  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2253  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2254  *q++=0U;
2255  p+=GetPixelChannels(image);
2256  }
2257  break;
2258  }
2259  if (LocaleCompare(stream_info->map,"I") == 0)
2260  {
2261  p=GetAuthenticPixelQueue(image);
2262  if (p == (const Quantum *) NULL)
2263  break;
2264  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2265  {
2266  *q++=ScaleQuantumToLongLong(ClampToQuantum(
2267  GetPixelIntensity(image,p)));
2268  p+=GetPixelChannels(image);
2269  }
2270  break;
2271  }
2272  if (LocaleCompare(stream_info->map,"RGB") == 0)
2273  {
2274  p=GetAuthenticPixelQueue(image);
2275  if (p == (const Quantum *) NULL)
2276  break;
2277  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2278  {
2279  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2280  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2281  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2282  p+=GetPixelChannels(image);
2283  }
2284  break;
2285  }
2286  if (LocaleCompare(stream_info->map,"RGBA") == 0)
2287  {
2288  p=GetAuthenticPixelQueue(image);
2289  if (p == (const Quantum *) NULL)
2290  break;
2291  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2292  {
2293  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2294  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2295  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2296  *q++=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2297  p+=GetPixelChannels(image);
2298  }
2299  break;
2300  }
2301  if (LocaleCompare(stream_info->map,"RGBP") == 0)
2302  {
2303  p=GetAuthenticPixelQueue(image);
2304  if (p == (const Quantum *) NULL)
2305  break;
2306  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2307  {
2308  *q++=ScaleQuantumToLongLong(GetPixelRed(image,p));
2309  *q++=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2310  *q++=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2311  *q++=0U;
2312  p+=GetPixelChannels(image);
2313  }
2314  break;
2315  }
2316  p=GetAuthenticPixelQueue(image);
2317  if (p == (const Quantum *) NULL)
2318  break;
2319  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2320  {
2321  for (i=0; i < (ssize_t) length; i++)
2322  {
2323  *q=0;
2324  switch (quantum_map[i])
2325  {
2326  case RedQuantum:
2327  case CyanQuantum:
2328  {
2329  *q=ScaleQuantumToLongLong(GetPixelRed(image,p));
2330  break;
2331  }
2332  case GreenQuantum:
2333  case MagentaQuantum:
2334  {
2335  *q=ScaleQuantumToLongLong(GetPixelGreen(image,p));
2336  break;
2337  }
2338  case BlueQuantum:
2339  case YellowQuantum:
2340  {
2341  *q=ScaleQuantumToLongLong(GetPixelBlue(image,p));
2342  break;
2343  }
2344  case AlphaQuantum:
2345  {
2346  *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2347  break;
2348  }
2349  case OpacityQuantum:
2350  {
2351  *q=ScaleQuantumToLongLong(GetPixelAlpha(image,p));
2352  break;
2353  }
2354  case BlackQuantum:
2355  {
2356  if (image->colorspace == CMYKColorspace)
2357  *q=ScaleQuantumToLongLong(GetPixelBlack(image,p));
2358  break;
2359  }
2360  case IndexQuantum:
2361  {
2362  *q=ScaleQuantumToLongLong(ClampToQuantum(
2363  GetPixelIntensity(image,p)));
2364  break;
2365  }
2366  default:
2367  *q=0;
2368  }
2369  q++;
2370  }
2371  p+=GetPixelChannels(image);
2372  }
2373  break;
2374  }
2375  case QuantumPixel:
2376  {
2377  register Quantum
2378  *q;
2379 
2380  q=(Quantum *) stream_info->pixels;
2381  if (LocaleCompare(stream_info->map,"BGR") == 0)
2382  {
2383  p=GetAuthenticPixelQueue(image);
2384  if (p == (const Quantum *) NULL)
2385  break;
2386  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2387  {
2388  *q++=GetPixelBlue(image,p);
2389  *q++=GetPixelGreen(image,p);
2390  *q++=GetPixelRed(image,p);
2391  p+=GetPixelChannels(image);
2392  }
2393  break;
2394  }
2395  if (LocaleCompare(stream_info->map,"BGRA") == 0)
2396  {
2397  p=GetAuthenticPixelQueue(image);
2398  if (p == (const Quantum *) NULL)
2399  break;
2400  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2401  {
2402  *q++=GetPixelBlue(image,p);
2403  *q++=GetPixelGreen(image,p);
2404  *q++=GetPixelRed(image,p);
2405  *q++=GetPixelAlpha(image,p);
2406  p+=GetPixelChannels(image);
2407  }
2408  break;
2409  }
2410  if (LocaleCompare(stream_info->map,"BGRP") == 0)
2411  {
2412  p=GetAuthenticPixelQueue(image);
2413  if (p == (const Quantum *) NULL)
2414  break;
2415  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2416  {
2417  *q++=GetPixelBlue(image,p);
2418  *q++=GetPixelGreen(image,p);
2419  *q++=GetPixelRed(image,p);
2420  *q++=0;
2421  p+=GetPixelChannels(image);
2422  }
2423  break;
2424  }
2425  if (LocaleCompare(stream_info->map,"I") == 0)
2426  {
2427  p=GetAuthenticPixelQueue(image);
2428  if (p == (const Quantum *) NULL)
2429  break;
2430  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2431  {
2432  *q++=ClampToQuantum(GetPixelIntensity(image,p));
2433  p+=GetPixelChannels(image);
2434  }
2435  break;
2436  }
2437  if (LocaleCompare(stream_info->map,"RGB") == 0)
2438  {
2439  p=GetAuthenticPixelQueue(image);
2440  if (p == (const Quantum *) NULL)
2441  break;
2442  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2443  {
2444  *q++=GetPixelRed(image,p);
2445  *q++=GetPixelGreen(image,p);
2446  *q++=GetPixelBlue(image,p);
2447  p+=GetPixelChannels(image);
2448  }
2449  break;
2450  }
2451  if (LocaleCompare(stream_info->map,"RGBA") == 0)
2452  {
2453  p=GetAuthenticPixelQueue(image);
2454  if (p == (const Quantum *) NULL)
2455  break;
2456  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2457  {
2458  *q++=GetPixelRed(image,p);
2459  *q++=GetPixelGreen(image,p);
2460  *q++=GetPixelBlue(image,p);
2461  *q++=GetPixelAlpha(image,p);
2462  p+=GetPixelChannels(image);
2463  }
2464  break;
2465  }
2466  if (LocaleCompare(stream_info->map,"RGBP") == 0)
2467  {
2468  p=GetAuthenticPixelQueue(image);
2469  if (p == (const Quantum *) NULL)
2470  break;
2471  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2472  {
2473  *q++=GetPixelRed(image,p);
2474  *q++=GetPixelGreen(image,p);
2475  *q++=GetPixelBlue(image,p);
2476  *q++=0U;
2477  p+=GetPixelChannels(image);
2478  }
2479  break;
2480  }
2481  p=GetAuthenticPixelQueue(image);
2482  if (p == (const Quantum *) NULL)
2483  break;
2484  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2485  {
2486  for (i=0; i < (ssize_t) length; i++)
2487  {
2488  *q=(Quantum) 0;
2489  switch (quantum_map[i])
2490  {
2491  case RedQuantum:
2492  case CyanQuantum:
2493  {
2494  *q=GetPixelRed(image,p);
2495  break;
2496  }
2497  case GreenQuantum:
2498  case MagentaQuantum:
2499  {
2500  *q=GetPixelGreen(image,p);
2501  break;
2502  }
2503  case BlueQuantum:
2504  case YellowQuantum:
2505  {
2506  *q=GetPixelBlue(image,p);
2507  break;
2508  }
2509  case AlphaQuantum:
2510  {
2511  *q=(Quantum) (GetPixelAlpha(image,p));
2512  break;
2513  }
2514  case OpacityQuantum:
2515  {
2516  *q=GetPixelAlpha(image,p);
2517  break;
2518  }
2519  case BlackQuantum:
2520  {
2521  if (image->colorspace == CMYKColorspace)
2522  *q=GetPixelBlack(image,p);
2523  break;
2524  }
2525  case IndexQuantum:
2526  {
2527  *q=ClampToQuantum(GetPixelIntensity(image,p));
2528  break;
2529  }
2530  default:
2531  *q=0;
2532  }
2533  q++;
2534  }
2535  p+=GetPixelChannels(image);
2536  }
2537  break;
2538  }
2539  case ShortPixel:
2540  {
2541  register unsigned short
2542  *q;
2543 
2544  q=(unsigned short *) stream_info->pixels;
2545  if (LocaleCompare(stream_info->map,"BGR") == 0)
2546  {
2547  p=GetAuthenticPixelQueue(image);
2548  if (p == (const Quantum *) NULL)
2549  break;
2550  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2551  {
2552  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2553  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2554  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2555  p+=GetPixelChannels(image);
2556  }
2557  break;
2558  }
2559  if (LocaleCompare(stream_info->map,"BGRA") == 0)
2560  {
2561  p=GetAuthenticPixelQueue(image);
2562  if (p == (const Quantum *) NULL)
2563  break;
2564  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2565  {
2566  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2567  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2568  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2569  *q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(image,p)));
2570  p+=GetPixelChannels(image);
2571  }
2572  break;
2573  }
2574  if (LocaleCompare(stream_info->map,"BGRP") == 0)
2575  {
2576  p=GetAuthenticPixelQueue(image);
2577  if (p == (const Quantum *) NULL)
2578  break;
2579  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2580  {
2581  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2582  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2583  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2584  *q++=0;
2585  p+=GetPixelChannels(image);
2586  }
2587  break;
2588  }
2589  if (LocaleCompare(stream_info->map,"I") == 0)
2590  {
2591  p=GetAuthenticPixelQueue(image);
2592  if (p == (const Quantum *) NULL)
2593  break;
2594  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2595  {
2596  *q++=ScaleQuantumToShort(ClampToQuantum(
2597  GetPixelIntensity(image,p)));
2598  p+=GetPixelChannels(image);
2599  }
2600  break;
2601  }
2602  if (LocaleCompare(stream_info->map,"RGB") == 0)
2603  {
2604  p=GetAuthenticPixelQueue(image);
2605  if (p == (const Quantum *) NULL)
2606  break;
2607  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2608  {
2609  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2610  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2611  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2612  p+=GetPixelChannels(image);
2613  }
2614  break;
2615  }
2616  if (LocaleCompare(stream_info->map,"RGBA") == 0)
2617  {
2618  p=GetAuthenticPixelQueue(image);
2619  if (p == (const Quantum *) NULL)
2620  break;
2621  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2622  {
2623  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2624  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2625  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2626  *q++=ScaleQuantumToShort((Quantum) (GetPixelAlpha(image,p)));
2627  p+=GetPixelChannels(image);
2628  }
2629  break;
2630  }
2631  if (LocaleCompare(stream_info->map,"RGBP") == 0)
2632  {
2633  p=GetAuthenticPixelQueue(image);
2634  if (p == (const Quantum *) NULL)
2635  break;
2636  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2637  {
2638  *q++=ScaleQuantumToShort(GetPixelRed(image,p));
2639  *q++=ScaleQuantumToShort(GetPixelGreen(image,p));
2640  *q++=ScaleQuantumToShort(GetPixelBlue(image,p));
2641  *q++=0;
2642  p+=GetPixelChannels(image);
2643  }
2644  break;
2645  }
2646  p=GetAuthenticPixelQueue(image);
2647  if (p == (const Quantum *) NULL)
2648  break;
2649  for (x=0; x < (ssize_t) GetImageExtent(image); x++)
2650  {
2651  for (i=0; i < (ssize_t) length; i++)
2652  {
2653  *q=0;
2654  switch (quantum_map[i])
2655  {
2656  case RedQuantum:
2657  case CyanQuantum:
2658  {
2659  *q=ScaleQuantumToShort(GetPixelRed(image,p));
2660  break;
2661  }
2662  case GreenQuantum:
2663  case MagentaQuantum:
2664  {
2665  *q=ScaleQuantumToShort(GetPixelGreen(image,p));
2666  break;
2667  }
2668  case BlueQuantum:
2669  case YellowQuantum:
2670  {
2671  *q=ScaleQuantumToShort(GetPixelBlue(image,p));
2672  break;
2673  }
2674  case AlphaQuantum:
2675  {
2676  *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
2677  break;
2678  }
2679  case OpacityQuantum:
2680  {
2681  *q=ScaleQuantumToShort(GetPixelAlpha(image,p));
2682  break;
2683  }
2684  case BlackQuantum:
2685  {
2686  if (image->colorspace == CMYKColorspace)
2687  *q=ScaleQuantumToShort(GetPixelBlack(image,p));
2688  break;
2689  }
2690  case IndexQuantum:
2691  {
2692  *q=ScaleQuantumToShort(ClampToQuantum(
2693  GetPixelIntensity(image,p)));
2694  break;
2695  }
2696  default:
2697  break;
2698  }
2699  q++;
2700  }
2701  p+=GetPixelChannels(image);
2702  }
2703  break;
2704  }
2705  default:
2706  {
2707  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2709  "UnrecognizedPixelMap","`%s'",stream_info->map);
2710  break;
2711  }
2712  }
2713  quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
2714  return(MagickTrue);
2715 }
2716 
2717 /*
2718 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2719 % %
2720 % %
2721 % %
2722 + S y n c A u t h e n t i c P i x e l s S t r e a m %
2723 % %
2724 % %
2725 % %
2726 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2727 %
2728 % SyncAuthenticPixelsStream() calls the user supplied callback method with
2729 % the latest stream of pixels.
2730 %
2731 % The format of the SyncAuthenticPixelsStream method is:
2732 %
2733 % MagickBooleanType SyncAuthenticPixelsStream(Image *image,
2734 % ExceptionInfo *exception)
2735 %
2736 % A description of each parameter follows:
2737 %
2738 % o image: the image.
2739 %
2740 % o exception: return any errors or warnings in this structure.
2741 %
2742 */
2744  ExceptionInfo *exception)
2745 {
2746  CacheInfo
2747  *cache_info;
2748 
2749  size_t
2750  length;
2751 
2753  stream_handler;
2754 
2755  assert(image != (Image *) NULL);
2756  assert(image->signature == MagickCoreSignature);
2757  if (image->debug != MagickFalse)
2758  (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2759  cache_info=(CacheInfo *) image->cache;
2760  assert(cache_info->signature == MagickCoreSignature);
2761  stream_handler=GetBlobStreamHandler(image);
2762  if (stream_handler == (StreamHandler) NULL)
2763  {
2765  "NoStreamHandlerIsDefined","`%s'",image->filename);
2766  return(MagickFalse);
2767  }
2768  length=stream_handler(image,cache_info->pixels,(size_t) cache_info->columns);
2769  return(length == cache_info->columns ? MagickTrue : MagickFalse);
2770 }
2771 
2772 /*
2773 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2774 % %
2775 % %
2776 % %
2777 % W r i t e S t r e a m %
2778 % %
2779 % %
2780 % %
2781 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2782 %
2783 % WriteStream() makes the image pixels available to a user supplied callback
2784 % method immediately upon writing pixel data with the WriteImage() method.
2785 %
2786 % The format of the WriteStream() method is:
2787 %
2788 % MagickBooleanType WriteStream(const ImageInfo *image_info,Image *,
2789 % StreamHandler stream,ExceptionInfo *exception)
2790 %
2791 % A description of each parameter follows:
2792 %
2793 % o image_info: the image info.
2794 %
2795 % o stream: A callback method.
2796 %
2797 % o exception: return any errors or warnings in this structure.
2798 %
2799 */
2801  Image *image,StreamHandler stream,ExceptionInfo *exception)
2802 {
2803  ImageInfo
2804  *write_info;
2805 
2807  status;
2808 
2809  assert(image_info != (ImageInfo *) NULL);
2810  assert(image_info->signature == MagickCoreSignature);
2811  if (image_info->debug != MagickFalse)
2813  image_info->filename);
2814  assert(image != (Image *) NULL);
2815  assert(image->signature == MagickCoreSignature);
2816  write_info=CloneImageInfo(image_info);
2817  *write_info->magick='\0';
2818  write_info->stream=stream;
2819  status=WriteImage(write_info,image,exception);
2820  write_info=DestroyImageInfo(write_info);
2821  return(status);
2822 }
static void RelinquishStreamPixels(CacheInfo *cache_info)
Definition: stream.c:201
MagickExport Quantum * GetAuthenticPixelQueue(const Image *image)
Definition: cache.c:1421
size_t rows
Definition: image.h:172
static MagickBooleanType GetOneAuthenticPixelFromStream(Image *image, const ssize_t x, const ssize_t y, Quantum *pixel, ExceptionInfo *exception)
Definition: stream.c:445
MagickExport void InitializePixelChannelMap(Image *image)
Definition: pixel.c:4328
SemaphoreInfo * file_semaphore
size_t signature
Definition: image.h:488
MagickSizeType length
GetVirtualPixelsHandler get_virtual_pixels_handler
Definition: cache-private.h:74
char magick[MagickPathExtent]
Definition: image.h:480
static Quantum GetPixelAlpha(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport StreamInfo * DestroyStreamInfo(StreamInfo *stream_info)
Definition: stream.c:270
MagickExport void UnlockSemaphoreInfo(SemaphoreInfo *semaphore_info)
Definition: semaphore.c:450
#define MagickAssumeAligned(address)
static Quantum GetPixelRed(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
void * metacontent
char * extract
Definition: image.h:390
char * map
Definition: stream.c:84
GetVirtualPixelHandler get_virtual_pixel_handler
Definition: cache-private.h:71
#define ThrowFatalException(severity, tag)
MagickPrivate void GetPixelCacheMethods(CacheMethods *)
MagickExport void SetStreamInfoStorageType(StreamInfo *stream_info, const StorageType storage_type)
Definition: stream.c:1165
size_t signature
Definition: exception.h:123
MagickExport void SetStreamInfoMap(StreamInfo *stream_info, const char *map)
Definition: stream.c:1133
MagickExport MagickStatusType ParseAbsoluteGeometry(const char *geometry, RectangleInfo *region_info)
Definition: geometry.c:703
StorageType
Definition: pixel.h:143
MagickPrivate void ResetStreamAnonymousMemory(void)
Definition: stream.c:1071
MagickBooleanType debug
Definition: image.h:485
SyncAuthenticPixelsHandler sync_authentic_pixels_handler
Definition: cache-private.h:98
VirtualPixelMethod
Definition: cache-view.h:27
Definition: blob.h:31
MagickRealType red
Definition: pixel.h:191
MagickExport ssize_t WriteBlob(Image *, const size_t, const void *)
const Image * image
Definition: stream.c:75
static void * AcquireCriticalMemory(const size_t size)
GetOneVirtualPixelFromHandler get_one_virtual_pixel_from_handler
Definition: cache-private.h:80
MagickExport StreamInfo * AcquireStreamInfo(const ImageInfo *image_info, ExceptionInfo *exception)
Definition: stream.c:159
MagickRealType alpha
Definition: pixel.h:191
static void * GetAuthenticMetacontentFromStream(const Image *image)
Definition: stream.c:316
ClassType storage_class
Definition: image.h:154
size_t width
Definition: geometry.h:130
MagickPrivate NexusInfo ** DestroyPixelCacheNexus(NexusInfo **, const size_t)
Definition: cache.c:1116
const void * client_data
Definition: stream.c:102
Definition: log.h:52
Definition: image.h:151
void * cache
Definition: image.h:464
MagickPrivate void SetStreamInfoClientData(StreamInfo *stream_info, const void *client_data)
Definition: stream.c:1101
static MagickBooleanType StreamImagePixels(const StreamInfo *, const Image *, ExceptionInfo *)
Definition: stream.c:1361
StreamHandler stream
Definition: image.h:468
size_t number_channels
static Quantum * QueueAuthenticPixelsStream(Image *, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo *)
Definition: stream.c:881
GetAuthenticPixelsHandler get_authentic_pixels_handler
Definition: cache-private.h:83
Quantum * pixels
#define MagickCoreSignature
MagickExport void LockSemaphoreInfo(SemaphoreInfo *semaphore_info)
Definition: semaphore.c:293
MagickExport MagickBooleanType WriteStream(const ImageInfo *image_info, Image *image, StreamHandler stream, ExceptionInfo *exception)
Definition: stream.c:2800
MagickPrivate ClassType GetPixelCacheStorageClass(const Cache)
Definition: cache.c:2361
MagickBooleanType
Definition: magick-type.h:156
MagickExport MagickBooleanType WriteImage(const ImageInfo *image_info, Image *image, ExceptionInfo *exception)
Definition: constitute.c:1032
size_t signature
Definition: stream.c:105
static size_t WriteStreamImage(const Image *image, const void *pixels, const size_t columns)
Definition: stream.c:1206
static const Quantum * GetVirtualPixelStream(const Image *, const VirtualPixelMethod, const ssize_t, const ssize_t, const size_t, const size_t, ExceptionInfo *)
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:533
static MagickBooleanType SyncAuthenticPixelsStream(Image *, ExceptionInfo *)
Definition: stream.c:2743
char filename[MagickPathExtent]
Definition: image.h:480
GetAuthenticPixelsFromHandler get_authentic_pixels_from_handler
Definition: cache-private.h:92
ssize_t y
Definition: stream.c:96
MagickExport MagickBooleanType CloseBlob(Image *)
QueueAuthenticPixelsHandler queue_authentic_pixels_handler
Definition: cache-private.h:95
#define magick_unused(x)
size_t MagickSizeType
Definition: magick-type.h:128
#define MagickPathExtent
void * cache
Definition: image.h:294
static Quantum GetPixelGreen(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport void * RelinquishAlignedMemory(void *memory)
Definition: memory.c:1017
MagickRealType blue
Definition: pixel.h:191
static ssize_t cache_anonymous_memory
Definition: stream.c:132
DestroyPixelHandler destroy_pixel_handler
static Quantum GetPixelBlack(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
MagickExport Image * ReadImage(const ImageInfo *image_info, ExceptionInfo *exception)
Definition: constitute.c:415
MagickExport MagickBooleanType SetImageInfo(ImageInfo *image_info, const unsigned int frames, ExceptionInfo *exception)
Definition: image.c:2701
static MagickBooleanType AcquireStreamPixels(CacheInfo *cache_info, ExceptionInfo *exception)
Definition: stream.c:682
MagickExport MagickBooleanType ThrowMagickException(ExceptionInfo *exception, const char *module, const char *function, const size_t line, const ExceptionType severity, const char *tag, const char *format,...)
Definition: exception.c:1064
SemaphoreInfo * semaphore
MagickExport MagickBooleanType LogMagickEvent(const LogEventType type, const char *module, const char *function, const size_t line, const char *format,...)
Definition: log.c:1398
ColorspaceType colorspace
ExceptionInfo * exception
Definition: stream.c:99
size_t signature
Definition: image.h:354
#define QuantumScale
Definition: magick-type.h:113
size_t columns
Definition: image.h:172
MagickBooleanType mapped
MagickExport Image * AcquireImage(const ImageInfo *image_info, ExceptionInfo *exception)
Definition: image.c:155
MagickExport MagickBooleanType OpenBlob(const ImageInfo *, Image *, const BlobMode, ExceptionInfo *)
ssize_t x
Definition: geometry.h:134
size_t height
Definition: geometry.h:130
GetVirtualMetacontentFromHandler get_virtual_metacontent_from_handler
Definition: cache-private.h:77
size_t signature
MagickExport Image * ReadStream(const ImageInfo *image_info, StreamHandler stream, ExceptionInfo *exception)
Definition: stream.c:1002
MagickExport size_t CopyMagickString(char *destination, const char *source, const size_t length)
Definition: string.c:755
GetAuthenticMetacontentFromHandler get_authentic_metacontent_from_handler
Definition: cache-private.h:86
static MagickBooleanType GetOneVirtualPixelFromStream(const Image *image, const VirtualPixelMethod virtual_pixel_method, const ssize_t x, const ssize_t y, Quantum *pixel, ExceptionInfo *exception)
Definition: stream.c:508
PixelChannel
Definition: pixel.h:67
MagickExport void * AcquireAlignedMemory(const size_t count, const size_t quantum)
Definition: memory.c:242
StorageType storage_type
Definition: stream.c:87
size_t metacontent_extent
static const void * GetVirtualMetacontentFromStream(const Image *image)
Definition: stream.c:632
static size_t GetPixelChannels(const Image *magick_restrict image)
MagickExport MagickSizeType GetImageExtent(const Image *image)
Definition: cache.c:1597
MagickExport int LocaleCompare(const char *p, const char *q)
Definition: locale.c:1440
char filename[MagickPathExtent]
Definition: image.h:319
#define GetMagickModule()
Definition: log.h:28
size_t number_threads
size_t columns
static Quantum ClampToQuantum(const MagickRealType value)
Definition: quantum.h:84
static PixelChannel GetPixelChannelChannel(const Image *magick_restrict image, const ssize_t offset)
void * client_data
Definition: image.h:464
MagickExport ImageInfo * DestroyImageInfo(ImageInfo *image_info)
Definition: image.c:1248
static Quantum * GetAuthenticPixelsStream(Image *image, const ssize_t x, const ssize_t y, const size_t columns, const size_t rows, ExceptionInfo *exception)
Definition: stream.c:362
unsigned short Quantum
Definition: magick-type.h:82
MagickPrivate void ResetPixelCacheChannels(Image *)
MagickPrivate ColorspaceType GetPixelCacheColorspace(const Cache)
Definition: cache.c:2155
char filename[MagickPathExtent]
const ImageInfo * image_info
Definition: stream.c:72
ClassType storage_class
MagickRealType black
Definition: pixel.h:191
MagickExport char * DestroyString(char *string)
Definition: string.c:823
NexusInfo ** nexus_info
MagickExport ImageInfo * CloneImageInfo(const ImageInfo *image_info)
Definition: image.c:937
GetOneAuthenticPixelFromHandler get_one_authentic_pixel_from_handler
Definition: cache-private.h:89
static Quantum * GetAuthenticPixelsFromStream(const Image *image)
Definition: stream.c:400
MagickExport char * GetPolicyValue(const char *name)
Definition: policy.c:505
static void DestroyPixelStream(Image *image)
Definition: stream.c:214
QuantumType
Definition: quantum.h:50
MagickExport void * RelinquishMagickMemory(void *memory)
Definition: memory.c:1054
#define MaxPixelChannels
Definition: pixel.h:27
#define magick_unreferenced(x)
MagickExport MagickBooleanType UnmapBlob(void *, const size_t)
Definition: blob.c:5479
MagickRealType green
Definition: pixel.h:191
MagickExport char * CloneString(char **destination, const char *source)
Definition: string.c:286
MagickExport MagickBooleanType OpenStream(const ImageInfo *image_info, StreamInfo *stream_info, const char *filename, ExceptionInfo *exception)
Definition: stream.c:838
MagickPrivate const void * GetStreamInfoClientData(StreamInfo *stream_info)
Definition: stream.c:561
MagickExport Image * StreamImage(const ImageInfo *image_info, StreamInfo *stream_info, ExceptionInfo *exception)
Definition: stream.c:1296
#define MagickPrivate
#define MagickExport
MagickExport StreamHandler GetBlobStreamHandler(const Image *image)
Definition: blob.c:1927
ssize_t y
Definition: geometry.h:134
Image * stream
Definition: stream.c:78
unsigned char * pixels
Definition: stream.c:90
RectangleInfo extract_info
Definition: stream.c:93
static Quantum GetPixelBlue(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
static const Quantum * GetVirtualPixelsStream(const Image *image)
Definition: stream.c:594
MagickExport MagickRealType GetPixelIntensity(const Image *magick_restrict image, const Quantum *magick_restrict pixel)
Definition: pixel.c:2358
PixelInfo background_color
Definition: image.h:179
MagickExport void RelinquishSemaphoreInfo(SemaphoreInfo **semaphore_info)
Definition: semaphore.c:351
void * client_data
Definition: image.h:306
MagickExport Image * DestroyImage(Image *image)
Definition: image.c:1177
MagickExport char * ConstantString(const char *source)
Definition: string.c:700
QuantumInfo * quantum_info
Definition: stream.c:81
MagickExport QuantumInfo * AcquireQuantumInfo(const ImageInfo *image_info, Image *image)
Definition: quantum.c:110
ColorspaceType colorspace
Definition: image.h:157
MagickPrivate void SetPixelCacheMethods(Cache, CacheMethods *)
Definition: cache.c:4858
size_t(* StreamHandler)(const Image *, const void *, const size_t)
Definition: stream.h:31
MagickExport QuantumInfo * DestroyQuantumInfo(QuantumInfo *quantum_info)
Definition: quantum.c:213
MagickBooleanType debug
Definition: image.h:334
MagickPrivate Cache AcquirePixelCache(const size_t)
MagickExport void * MapBlob(int, const MapMode, const MagickOffsetType, const size_t)
ssize_t reference_count