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-2019 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"
45 #include "MagickCore/blob-private.h"
46 #include "MagickCore/cache.h"
47 #include "MagickCore/cache-private.h"
48 #include "MagickCore/color-private.h"
49 #include "MagickCore/composite-private.h"
50 #include "MagickCore/constitute.h"
51 #include "MagickCore/exception.h"
52 #include "MagickCore/exception-private.h"
53 #include "MagickCore/geometry.h"
54 #include "MagickCore/memory_.h"
55 #include "MagickCore/memory-private.h"
56 #include "MagickCore/pixel.h"
57 #include "MagickCore/pixel-accessor.h"
58 #include "MagickCore/policy.h"
59 #include "MagickCore/quantum.h"
60 #include "MagickCore/quantum-private.h"
61 #include "MagickCore/semaphore.h"
62 #include "MagickCore/stream.h"
63 #include "MagickCore/stream-private.h"
64 #include "MagickCore/string_.h"
65
66 /*
67 Typedef declaractions.
68 */
69 struct _StreamInfo
70 {
71 const ImageInfo
72 *image_info;
73
74 const Image
75 *image;
76
77 Image
78 *stream;
79
80 QuantumInfo
81 *quantum_info;
82
83 char
84 *map;
85
86 StorageType
87 storage_type;
88
89 unsigned char
90 *pixels;
91
92 RectangleInfo
93 extract_info;
94
95 ssize_t
96 y;
97
98 ExceptionInfo
99 *exception;
100
101 const void
102 *client_data;
103
104 size_t
105 signature;
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 *),
121 SyncAuthenticPixelsStream(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
132 cache_anonymous_memory = (-1);
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 */
AcquireStreamInfo(const ImageInfo * image_info,ExceptionInfo * exception)159 MagickExport StreamInfo *AcquireStreamInfo(const ImageInfo *image_info,
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
RelinquishStreamPixels(CacheInfo * cache_info)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
DestroyPixelStream(Image * image)214 static void DestroyPixelStream(Image *image)
215 {
216 CacheInfo
217 *cache_info;
218
219 MagickBooleanType
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)
241 RelinquishSemaphoreInfo(&cache_info->file_semaphore);
242 if (cache_info->semaphore != (SemaphoreInfo *) NULL)
243 RelinquishSemaphoreInfo(&cache_info->semaphore);
244 cache_info=(CacheInfo *) RelinquishAlignedMemory(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 */
DestroyStreamInfo(StreamInfo * stream_info)270 MagickExport StreamInfo *DestroyStreamInfo(StreamInfo *stream_info)
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 */
GetAuthenticMetacontentFromStream(const Image * image)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 */
GetAuthenticPixelsStream(Image * image,const ssize_t x,const ssize_t y,const size_t columns,const size_t rows,ExceptionInfo * exception)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 */
GetAuthenticPixelsFromStream(const Image * image)400 static Quantum *GetAuthenticPixelsFromStream(const Image *image)
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 */
GetOneAuthenticPixelFromStream(Image * image,const ssize_t x,const ssize_t y,Quantum * pixel,ExceptionInfo * exception)445 static MagickBooleanType GetOneAuthenticPixelFromStream(Image *image,
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 {
460 pixel[RedPixelChannel]=ClampToQuantum(image->background_color.red);
461 pixel[GreenPixelChannel]=ClampToQuantum(image->background_color.green);
462 pixel[BluePixelChannel]=ClampToQuantum(image->background_color.blue);
463 pixel[BlackPixelChannel]=ClampToQuantum(image->background_color.black);
464 pixel[AlphaPixelChannel]=ClampToQuantum(image->background_color.alpha);
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 */
GetOneVirtualPixelFromStream(const Image * image,const VirtualPixelMethod virtual_pixel_method,const ssize_t x,const ssize_t y,Quantum * pixel,ExceptionInfo * exception)508 static MagickBooleanType GetOneVirtualPixelFromStream(const Image *image,
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 {
524 pixel[RedPixelChannel]=ClampToQuantum(image->background_color.red);
525 pixel[GreenPixelChannel]=ClampToQuantum(image->background_color.green);
526 pixel[BluePixelChannel]=ClampToQuantum(image->background_color.blue);
527 pixel[BlackPixelChannel]=ClampToQuantum(image->background_color.black);
528 pixel[AlphaPixelChannel]=ClampToQuantum(image->background_color.alpha);
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 */
GetStreamInfoClientData(StreamInfo * stream_info)561 MagickPrivate const void *GetStreamInfoClientData(StreamInfo *stream_info)
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 */
GetVirtualPixelsStream(const Image * image)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 */
GetVirtualMetacontentFromStream(const Image * image)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
AcquireStreamPixels(CacheInfo * cache_info,ExceptionInfo * exception)682 static inline MagickBooleanType AcquireStreamPixels(CacheInfo *cache_info,
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 */
695 cache_anonymous_memory=0;
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)
702 cache_anonymous_memory=1;
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
GetVirtualPixelStream(const Image * image,const VirtualPixelMethod magick_unused (virtual_pixel_method),const ssize_t x,const ssize_t y,const size_t columns,const size_t rows,ExceptionInfo * exception)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
742 MagickBooleanType
743 status;
744
745 MagickSizeType
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 {
765 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
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 */
OpenStream(const ImageInfo * image_info,StreamInfo * stream_info,const char * filename,ExceptionInfo * exception)838 MagickExport MagickBooleanType OpenStream(const ImageInfo *image_info,
839 StreamInfo *stream_info,const char *filename,ExceptionInfo *exception)
840 {
841 MagickBooleanType
842 status;
843
844 (void) CopyMagickString(stream_info->stream->filename,filename,
845 MagickPathExtent);
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 */
QueueAuthenticPixelsStream(Image * image,const ssize_t x,const ssize_t y,const size_t columns,const size_t rows,ExceptionInfo * exception)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
888 MagickBooleanType
889 status;
890
891 MagickSizeType
892 number_pixels;
893
894 size_t
895 length;
896
897 StreamHandler
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 {
909 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
910 "ImageDoesNotContainTheStreamGeometry","`%s'",image->filename);
911 return((Quantum *) NULL);
912 }
913 stream_handler=GetBlobStreamHandler(image);
914 if (stream_handler == (StreamHandler) NULL)
915 {
916 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
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 {
925 if (GetPixelCacheStorageClass(image->cache) == UndefinedClass)
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 */
ReadStream(const ImageInfo * image_info,StreamHandler stream,ExceptionInfo * exception)1002 MagickExport Image *ReadStream(const ImageInfo *image_info,StreamHandler stream,
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)
1020 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
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);
1027 cache_methods.get_virtual_pixel_handler=GetVirtualPixelStream;
1028 cache_methods.get_virtual_pixels_handler=GetVirtualPixelsStream;
1029 cache_methods.get_virtual_metacontent_from_handler=
1030 GetVirtualMetacontentFromStream;
1031 cache_methods.get_authentic_pixels_handler=GetAuthenticPixelsStream;
1032 cache_methods.queue_authentic_pixels_handler=QueueAuthenticPixelsStream;
1033 cache_methods.sync_authentic_pixels_handler=SyncAuthenticPixelsStream;
1034 cache_methods.get_authentic_pixels_from_handler=GetAuthenticPixelsFromStream;
1035 cache_methods.get_authentic_metacontent_from_handler=
1036 GetAuthenticMetacontentFromStream;
1037 cache_methods.get_one_virtual_pixel_from_handler=GetOneVirtualPixelFromStream;
1038 cache_methods.get_one_authentic_pixel_from_handler=
1039 GetOneAuthenticPixelFromStream;
1040 cache_methods.destroy_pixel_handler=DestroyPixelStream;
1041 SetPixelCacheMethods(read_info->cache,&cache_methods);
1042 read_info->stream=stream;
1043 image=ReadImage(read_info,exception);
1044 if (image != (Image *) NULL)
1045 {
1046 InitializePixelChannelMap(image);
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 */
ResetStreamAnonymousMemory(void)1071 MagickPrivate void ResetStreamAnonymousMemory(void)
1072 {
1073 cache_anonymous_memory=0;
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 */
SetStreamInfoClientData(StreamInfo * stream_info,const void * client_data)1101 MagickPrivate void SetStreamInfoClientData(StreamInfo *stream_info,
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 */
SetStreamInfoMap(StreamInfo * stream_info,const char * map)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 */
SetStreamInfoStorageType(StreamInfo * stream_info,const StorageType storage_type)1165 MagickExport void SetStreamInfoStorageType(StreamInfo *stream_info,
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
WriteStreamImage(const Image * image,const void * pixels,const size_t columns)1206 static size_t WriteStreamImage(const Image *image,const void *pixels,
1207 const size_t columns)
1208 {
1209 CacheInfo
1210 *cache_info;
1211
1212 RectangleInfo
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
StreamImage(const ImageInfo * image_info,StreamInfo * stream_info,ExceptionInfo * exception)1296 MagickExport Image *StreamImage(const ImageInfo *image_info,
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)
1308 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
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 */
StreamImagePixels(const StreamInfo * stream_info,const Image * image,ExceptionInfo * exception)1361 static MagickBooleanType StreamImagePixels(const StreamInfo *stream_info,
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);
1488 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
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);
2708 (void) ThrowMagickException(exception,GetMagickModule(),OptionError,
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 */
SyncAuthenticPixelsStream(Image * image,ExceptionInfo * exception)2743 static MagickBooleanType SyncAuthenticPixelsStream(Image *image,
2744 ExceptionInfo *exception)
2745 {
2746 CacheInfo
2747 *cache_info;
2748
2749 size_t
2750 length;
2751
2752 StreamHandler
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 {
2764 (void) ThrowMagickException(exception,GetMagickModule(),StreamError,
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 */
WriteStream(const ImageInfo * image_info,Image * image,StreamHandler stream,ExceptionInfo * exception)2800 MagickExport MagickBooleanType WriteStream(const ImageInfo *image_info,
2801 Image *image,StreamHandler stream,ExceptionInfo *exception)
2802 {
2803 ImageInfo
2804 *write_info;
2805
2806 MagickBooleanType
2807 status;
2808
2809 assert(image_info != (ImageInfo *) NULL);
2810 assert(image_info->signature == MagickCoreSignature);
2811 if (image_info->debug != MagickFalse)
2812 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
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 }
2823