MagickCore 6.9.13-47
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
blob.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% BBBB L OOO BBBB %
7% B B L O O B B %
8% BBBB L O O BBBB %
9% B B L O O B B %
10% BBBB LLLLL OOO BBBB %
11% %
12% %
13% MagickCore Binary Large OBjectS Methods %
14% %
15% Software Design %
16% Cristy %
17% July 1999 %
18% %
19% %
20% Copyright 1999 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/license/ %
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#ifdef __VMS
44#include <types.h>
45#include <mman.h>
46#endif
47#include "magick/studio.h"
48#include "magick/blob.h"
49#include "magick/blob-private.h"
50#include "magick/cache.h"
51#include "magick/client.h"
52#include "magick/constitute.h"
53#include "magick/delegate.h"
54#include "magick/exception.h"
55#include "magick/exception-private.h"
56#include "magick/geometry.h"
57#include "magick/image-private.h"
58#include "magick/list.h"
59#include "magick/locale_.h"
60#include "magick/log.h"
61#include "magick/magick.h"
62#include "magick/memory_.h"
63#include "magick/nt-base-private.h"
64#include "magick/option.h"
65#include "magick/policy.h"
66#include "magick/resource_.h"
67#include "magick/semaphore.h"
68#include "magick/string_.h"
69#include "magick/string-private.h"
70#include "magick/timer-private.h"
71#include "magick/token.h"
72#include "magick/utility.h"
73#include "magick/utility-private.h"
74#if defined(MAGICKCORE_ZLIB_DELEGATE)
75#include "zlib.h"
76#endif
77#if defined(MAGICKCORE_BZLIB_DELEGATE)
78#include "bzlib.h"
79#endif
80␌
81/*
82 Define declarations.
83*/
84#define IsPathAuthorized(rights,filename) \
85 ((IsRightsAuthorized(PathPolicyDomain,rights,filename) != MagickFalse) && \
86 ((IsRightsAuthorized(SystemPolicyDomain,rights,"symlink::follow") != MagickFalse) || \
87 (is_symlink_utf8(filename) == MagickFalse)))
88#define MagickMaxBlobExtent (8*8192)
89#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
90# define MAP_ANONYMOUS MAP_ANON
91#endif
92#if !defined(MAP_FAILED)
93#define MAP_FAILED ((void *) -1)
94#endif
95#if defined(__OS2__)
96#include <io.h>
97#define _O_BINARY O_BINARY
98#endif
99#if defined(MAGICKCORE_WINDOWS_SUPPORT)
100# if !defined(fsync)
101# define fsync _commit
102# endif
103# if !defined(mmap)
104# define MAGICKCORE_HAVE_MMAP 1
105# define mmap(address,length,protection,access,file,offset) \
106 NTMapMemory(address,length,protection,access,file,offset)
107# endif
108# if !defined(munmap)
109# define munmap(address,length) NTUnmapMemory(address,length)
110# endif
111# if !defined(pclose)
112# define pclose _pclose
113# endif
114# if !defined(popen)
115# define popen _popen
116# endif
117#endif
118␌
119/*
120 Typedef declarations.
121*/
122typedef union FileInfo
123{
124 FILE
125 *file;
126
127#if defined(MAGICKCORE_ZLIB_DELEGATE)
128 gzFile
129 gzfile;
130#endif
131
132#if defined(MAGICKCORE_BZLIB_DELEGATE)
133 BZFILE
134 *bzfile;
135#endif
136} FileInfo;
137
138struct _BlobInfo
139{
140 size_t
141 length,
142 extent,
143 quantum;
144
145 BlobMode
146 mode;
147
148 MagickBooleanType
149 mapped,
150 eof;
151
152 int
153 error,
154 error_number;
155
156 MagickOffsetType
157 offset;
158
159 MagickSizeType
160 size;
161
162 MagickBooleanType
163 exempt,
164 synchronize,
165 temporary;
166
167 int
168 status;
169
170 StreamType
171 type;
172
173 FileInfo
174 file_info;
175
176 struct stat
177 properties;
178
179 StreamHandler
180 stream;
181
182 unsigned char
183 *data;
184
185 MagickBooleanType
186 debug;
187
188 SemaphoreInfo
189 *semaphore;
190
191 ssize_t
192 reference_count;
193
194 size_t
195 signature;
196};
197␌
198/*
199 Forward declarations.
200*/
201static int
202 SyncBlob(const Image *);
203␌
204/*
205%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
206% %
207% %
208% %
209+ A t t a c h B l o b %
210% %
211% %
212% %
213%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
214%
215% AttachBlob() attaches a blob to the BlobInfo structure.
216%
217% The format of the AttachBlob method is:
218%
219% void AttachBlob(BlobInfo *blob_info,const void *blob,const size_t length)
220%
221% A description of each parameter follows:
222%
223% o blob_info: Specifies a pointer to a BlobInfo structure.
224%
225% o blob: the address of a character stream in one of the image formats
226% understood by ImageMagick.
227%
228% o length: This size_t integer reflects the length in bytes of the blob.
229%
230*/
231MagickExport void AttachBlob(BlobInfo *blob_info,const void *blob,
232 const size_t length)
233{
234 assert(blob_info != (BlobInfo *) NULL);
235 if (IsEventLogging() != MagickFalse)
236 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
237 blob_info->length=length;
238 blob_info->extent=length;
239 blob_info->quantum=(size_t) MagickMaxBlobExtent;
240 blob_info->offset=0;
241 blob_info->type=BlobStream;
242 blob_info->file_info.file=(FILE *) NULL;
243 blob_info->data=(unsigned char *) blob;
244 blob_info->mapped=MagickFalse;
245}
246␌
247/*
248%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
249% %
250% %
251% %
252+ B l o b T o F i l e %
253% %
254% %
255% %
256%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
257%
258% BlobToFile() writes a blob to a file. It returns MagickFalse if an error
259% occurs otherwise MagickTrue.
260%
261% The format of the BlobToFile method is:
262%
263% MagickBooleanType BlobToFile(char *filename,const void *blob,
264% const size_t length,ExceptionInfo *exception)
265%
266% A description of each parameter follows:
267%
268% o filename: Write the blob to this file. The filename buffer length must
269% be a minimum of MagickPathExtent characters.
270%
271% o blob: the address of a blob.
272%
273% o length: This length in bytes of the blob.
274%
275% o exception: return any errors or warnings in this structure.
276%
277*/
278MagickExport MagickBooleanType BlobToFile(char *filename,const void *blob,
279 const size_t length,ExceptionInfo *exception)
280{
281 int
282 file;
283
284 size_t
285 i;
286
287 ssize_t
288 count;
289
290 assert(filename != (const char *) NULL);
291 assert(blob != (const void *) NULL);
292 if (IsEventLogging() != MagickFalse)
293 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
294 if (*filename == '\0')
295 file=AcquireUniqueFileResource(filename);
296 else
297 file=open_utf8(filename,O_WRONLY | O_CREAT | O_EXCL | O_BINARY,P_MODE);
298 if (file == -1)
299 {
300 ThrowFileException(exception,BlobError,"UnableToWriteBlob",filename);
301 return(MagickFalse);
302 }
303 for (i=0; i < length; i+=(size_t) count)
304 {
305 count=write(file,(const char *) blob+i,MagickMin(length-i,(size_t)
306 MagickMaxBufferExtent));
307 if (count <= 0)
308 {
309 count=0;
310 if (errno != EINTR)
311 break;
312 }
313 }
314 file=close_utf8(file);
315 if ((file == -1) || (i < length))
316 {
317 ThrowFileException(exception,BlobError,"UnableToWriteBlob",filename);
318 return(MagickFalse);
319 }
320 return(MagickTrue);
321}
322␌
323/*
324%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
325% %
326% %
327% %
328% B l o b T o I m a g e %
329% %
330% %
331% %
332%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
333%
334% BlobToImage() implements direct to memory image formats. It returns the
335% blob as an image.
336%
337% The format of the BlobToImage method is:
338%
339% Image *BlobToImage(const ImageInfo *image_info,const void *blob,
340% const size_t length,ExceptionInfo *exception)
341%
342% A description of each parameter follows:
343%
344% o image_info: the image info.
345%
346% o blob: the address of a character stream in one of the image formats
347% understood by ImageMagick.
348%
349% o length: This size_t integer reflects the length in bytes of the blob.
350%
351% o exception: return any errors or warnings in this structure.
352%
353*/
354MagickExport Image *BlobToImage(const ImageInfo *image_info,const void *blob,
355 const size_t length,ExceptionInfo *exception)
356{
357 const MagickInfo
358 *magick_info;
359
360 Image
361 *image;
362
363 ImageInfo
364 *blob_info,
365 *clone_info;
366
367 MagickBooleanType
368 status;
369
370 assert(image_info != (ImageInfo *) NULL);
371 assert(image_info->signature == MagickCoreSignature);
372 assert(exception != (ExceptionInfo *) NULL);
373 if (IsEventLogging() != MagickFalse)
374 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
375 image_info->filename);
376 if ((blob == (const void *) NULL) || (length == 0))
377 {
378 (void) ThrowMagickException(exception,GetMagickModule(),BlobError,
379 "ZeroLengthBlobNotPermitted","`%s'",image_info->filename);
380 return((Image *) NULL);
381 }
382 blob_info=CloneImageInfo(image_info);
383 blob_info->blob=(void *) blob;
384 blob_info->length=length;
385 if (*blob_info->magick == '\0')
386 (void) SetImageInfo(blob_info,0,exception);
387 magick_info=GetMagickInfo(blob_info->magick,exception);
388 if (magick_info == (const MagickInfo *) NULL)
389 {
390 (void) ThrowMagickException(exception,GetMagickModule(),
391 MissingDelegateError,"NoDecodeDelegateForThisImageFormat","`%s'",
392 blob_info->magick);
393 blob_info=DestroyImageInfo(blob_info);
394 return((Image *) NULL);
395 }
396 if (GetMagickBlobSupport(magick_info) != MagickFalse)
397 {
398 char
399 filename[MagickPathExtent];
400
401 /*
402 Native blob support for this image format.
403 */
404 (void) CopyMagickString(filename,blob_info->filename,MagickPathExtent);
405 (void) FormatLocaleString(blob_info->filename,MagickPathExtent,"%s:%s",
406 blob_info->magick,filename);
407 image=ReadImage(blob_info,exception);
408 if (image != (Image *) NULL)
409 (void) DetachBlob(image->blob);
410 blob_info=DestroyImageInfo(blob_info);
411 return(image);
412 }
413 /*
414 Write blob to a temporary file on disk.
415 */
416 blob_info->blob=(void *) NULL;
417 blob_info->length=0;
418 *blob_info->filename='\0';
419 status=BlobToFile(blob_info->filename,blob,length,exception);
420 if (status == MagickFalse)
421 {
422 (void) RelinquishUniqueFileResource(blob_info->filename);
423 blob_info=DestroyImageInfo(blob_info);
424 return((Image *) NULL);
425 }
426 clone_info=CloneImageInfo(blob_info);
427 (void) FormatLocaleString(clone_info->filename,MagickPathExtent,"%s:%s",
428 blob_info->magick,blob_info->filename);
429 image=ReadImage(clone_info,exception);
430 if (image != (Image *) NULL)
431 {
432 Image
433 *images;
434
435 /*
436 Restore original filenames and image format.
437 */
438 for (images=GetFirstImageInList(image); images != (Image *) NULL; )
439 {
440 (void) CopyMagickString(images->filename,image_info->filename,
441 MagickPathExtent);
442 (void) CopyMagickString(images->magick_filename,image_info->filename,
443 MagickPathExtent);
444 (void) CopyMagickString(images->magick,magick_info->name,
445 MagickPathExtent);
446 images=GetNextImageInList(images);
447 }
448 }
449 clone_info=DestroyImageInfo(clone_info);
450 (void) RelinquishUniqueFileResource(blob_info->filename);
451 blob_info=DestroyImageInfo(blob_info);
452 return(image);
453}
454␌
455/*
456%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
457% %
458% %
459% %
460+ C l o n e B l o b I n f o %
461% %
462% %
463% %
464%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
465%
466% CloneBlobInfo() makes a duplicate of the given blob info structure, or if
467% blob info is NULL, a new one.
468%
469% The format of the CloneBlobInfo method is:
470%
471% BlobInfo *CloneBlobInfo(const BlobInfo *blob_info)
472%
473% A description of each parameter follows:
474%
475% o blob_info: the blob info.
476%
477*/
478MagickExport BlobInfo *CloneBlobInfo(const BlobInfo *blob_info)
479{
480 BlobInfo
481 *clone_info;
482
483 SemaphoreInfo
484 *semaphore;
485
486 clone_info=(BlobInfo *) AcquireCriticalMemory(sizeof(*clone_info));
487 GetBlobInfo(clone_info);
488 if (blob_info == (BlobInfo *) NULL)
489 return(clone_info);
490 semaphore=clone_info->semaphore;
491 (void) memcpy(clone_info,blob_info,sizeof(*clone_info));
492 if (blob_info->mapped != MagickFalse)
493 (void) AcquireMagickResource(MapResource,blob_info->length);
494 clone_info->semaphore=semaphore;
495 LockSemaphoreInfo(clone_info->semaphore);
496 clone_info->reference_count=1;
497 UnlockSemaphoreInfo(clone_info->semaphore);
498 return(clone_info);
499}
500␌
501/*
502%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
503% %
504% %
505% %
506+ C l o s e B l o b %
507% %
508% %
509% %
510%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
511%
512% CloseBlob() closes a stream associated with the image.
513%
514% The format of the CloseBlob method is:
515%
516% MagickBooleanType CloseBlob(Image *image)
517%
518% A description of each parameter follows:
519%
520% o image: the image.
521%
522*/
523
524static inline void ThrowBlobException(BlobInfo *blob_info)
525{
526 if ((blob_info->status == 0) && (errno != 0))
527 blob_info->error_number=errno;
528 blob_info->status=(-1);
529}
530
531MagickExport MagickBooleanType CloseBlob(Image *image)
532{
533 BlobInfo
534 *magick_restrict blob_info;
535
536 int
537 status;
538
539 /*
540 Close image file.
541 */
542 assert(image != (Image *) NULL);
543 assert(image->signature == MagickCoreSignature);
544 if (IsEventLogging() != MagickFalse)
545 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
546 blob_info=image->blob;
547 if ((blob_info == (BlobInfo *) NULL) || (blob_info->type == UndefinedStream))
548 return(MagickTrue);
549 (void) SyncBlob(image);
550 status=blob_info->status;
551 switch (blob_info->type)
552 {
553 case UndefinedStream:
554 break;
555 case StandardStream:
556 case FileStream:
557 case PipeStream:
558 {
559 if (blob_info->synchronize != MagickFalse)
560 {
561 status=fflush(blob_info->file_info.file);
562 if (status != 0)
563 ThrowBlobException(blob_info);
564 status=fsync(fileno(blob_info->file_info.file));
565 if (status != 0)
566 ThrowBlobException(blob_info);
567 }
568 if ((status != 0) && (ferror(blob_info->file_info.file) != 0))
569 ThrowBlobException(blob_info);
570 break;
571 }
572 case ZipStream:
573 {
574#if defined(MAGICKCORE_ZLIB_DELEGATE)
575 status=Z_OK;
576 (void) gzerror(blob_info->file_info.gzfile,&status);
577 if (status != Z_OK)
578 ThrowBlobException(blob_info);
579#endif
580 break;
581 }
582 case BZipStream:
583 {
584#if defined(MAGICKCORE_BZLIB_DELEGATE)
585 status=BZ_OK;
586 (void) BZ2_bzerror(blob_info->file_info.bzfile,&status);
587 if (status != BZ_OK)
588 ThrowBlobException(blob_info);
589#endif
590 break;
591 }
592 case FifoStream:
593 break;
594 case BlobStream:
595 {
596 if (blob_info->file_info.file != (FILE *) NULL)
597 {
598 if (blob_info->synchronize != MagickFalse)
599 {
600 status=fflush(blob_info->file_info.file);
601 if (status != 0)
602 ThrowBlobException(blob_info);
603 status=fsync(fileno(blob_info->file_info.file));
604 if (status != 0)
605 ThrowBlobException(blob_info);
606 }
607 if ((status != 0) && (ferror(blob_info->file_info.file) != 0))
608 ThrowBlobException(blob_info);
609 }
610 break;
611 }
612 }
613 blob_info->size=GetBlobSize(image);
614 image->extent=blob_info->size;
615 blob_info->eof=MagickFalse;
616 blob_info->error=0;
617 blob_info->mode=UndefinedBlobMode;
618 if (blob_info->exempt != MagickFalse)
619 {
620 blob_info->type=UndefinedStream;
621 return(blob_info->status != 0 ? MagickFalse : MagickTrue);
622 }
623 switch (blob_info->type)
624 {
625 case UndefinedStream:
626 case StandardStream:
627 break;
628 case FileStream:
629 {
630 if (blob_info->file_info.file != (FILE *) NULL)
631 {
632 status=fclose(blob_info->file_info.file);
633 if (status != 0)
634 ThrowBlobException(blob_info);
635 }
636 break;
637 }
638 case PipeStream:
639 {
640#if defined(MAGICKCORE_HAVE_PCLOSE)
641 status=pclose(blob_info->file_info.file);
642 if (status != 0)
643 ThrowBlobException(blob_info);
644#endif
645 break;
646 }
647 case ZipStream:
648 {
649#if defined(MAGICKCORE_ZLIB_DELEGATE)
650 status=gzclose(blob_info->file_info.gzfile);
651 if (status != Z_OK)
652 ThrowBlobException(blob_info);
653#endif
654 break;
655 }
656 case BZipStream:
657 {
658#if defined(MAGICKCORE_BZLIB_DELEGATE)
659 BZ2_bzclose(blob_info->file_info.bzfile);
660#endif
661 break;
662 }
663 case FifoStream:
664 break;
665 case BlobStream:
666 {
667 if (blob_info->file_info.file != (FILE *) NULL)
668 {
669 status=fclose(blob_info->file_info.file);
670 if (status != 0)
671 ThrowBlobException(blob_info);
672 }
673 break;
674 }
675 }
676 (void) DetachBlob(blob_info);
677 return(blob_info->status != 0 ? MagickFalse : MagickTrue);
678}
679␌
680/*
681%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
682% %
683% %
684% %
685+ D e s t r o y B l o b %
686% %
687% %
688% %
689%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
690%
691% DestroyBlob() deallocates memory associated with a blob.
692%
693% The format of the DestroyBlob method is:
694%
695% void DestroyBlob(Image *image)
696%
697% A description of each parameter follows:
698%
699% o image: the image.
700%
701*/
702MagickExport void DestroyBlob(Image *image)
703{
704 BlobInfo
705 *magick_restrict blob_info;
706
707 MagickBooleanType
708 destroy;
709
710 assert(image != (Image *) NULL);
711 assert(image->signature == MagickCoreSignature);
712 assert(image->blob != (BlobInfo *) NULL);
713 assert(image->blob->signature == MagickCoreSignature);
714 if (IsEventLogging() != MagickFalse)
715 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
716 blob_info=image->blob;
717 destroy=MagickFalse;
718 LockSemaphoreInfo(blob_info->semaphore);
719 blob_info->reference_count--;
720 assert(blob_info->reference_count >= 0);
721 if (blob_info->reference_count == 0)
722 destroy=MagickTrue;
723 UnlockSemaphoreInfo(blob_info->semaphore);
724 if (destroy == MagickFalse)
725 {
726 image->blob=(BlobInfo *) NULL;
727 return;
728 }
729 (void) CloseBlob(image);
730 if (blob_info->mapped != MagickFalse)
731 {
732 (void) UnmapBlob(blob_info->data,blob_info->length);
733 RelinquishMagickResource(MapResource,blob_info->length);
734 }
735 if (blob_info->semaphore != (SemaphoreInfo *) NULL)
736 DestroySemaphoreInfo(&blob_info->semaphore);
737 blob_info->signature=(~MagickCoreSignature);
738 image->blob=(BlobInfo *) RelinquishMagickMemory(blob_info);
739}
740␌
741/*
742%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
743% %
744% %
745% %
746+ D e t a c h B l o b %
747% %
748% %
749% %
750%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
751%
752% DetachBlob() detaches a blob from the BlobInfo structure.
753%
754% The format of the DetachBlob method is:
755%
756% unsigned char *DetachBlob(BlobInfo *blob_info)
757%
758% A description of each parameter follows:
759%
760% o blob_info: Specifies a pointer to a BlobInfo structure.
761%
762*/
763MagickExport unsigned char *DetachBlob(BlobInfo *blob_info)
764{
765 unsigned char
766 *data;
767
768 assert(blob_info != (BlobInfo *) NULL);
769 if (IsEventLogging() != MagickFalse)
770 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
771 if (blob_info->mapped != MagickFalse)
772 {
773 (void) UnmapBlob(blob_info->data,blob_info->length);
774 blob_info->data=NULL;
775 RelinquishMagickResource(MapResource,blob_info->length);
776 }
777 blob_info->mapped=MagickFalse;
778 blob_info->length=0;
779 blob_info->offset=0;
780 blob_info->mode=UndefinedBlobMode;
781 blob_info->eof=MagickFalse;
782 blob_info->error=0;
783 blob_info->exempt=MagickFalse;
784 blob_info->type=UndefinedStream;
785 blob_info->file_info.file=(FILE *) NULL;
786 data=blob_info->data;
787 blob_info->data=(unsigned char *) NULL;
788 blob_info->stream=(StreamHandler) NULL;
789 return(data);
790}
791␌
792/*
793%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
794% %
795% %
796% %
797+ D i s a s s o c i a t e B l o b %
798% %
799% %
800% %
801%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
802%
803% DisassociateBlob() disassociates the image stream. It checks if the
804% blob of the specified image is referenced by other images. If the reference
805% count is higher then 1 a new blob is assigned to the specified image.
806%
807% The format of the DisassociateBlob method is:
808%
809% void DisassociateBlob(const Image *image)
810%
811% A description of each parameter follows:
812%
813% o image: the image.
814%
815*/
816MagickPrivate void DisassociateBlob(Image *image)
817{
818 BlobInfo
819 *magick_restrict blob_info,
820 *clone_info;
821
822 MagickBooleanType
823 clone;
824
825 assert(image != (Image *) NULL);
826 assert(image->signature == MagickCoreSignature);
827 assert(image->blob != (BlobInfo *) NULL);
828 assert(image->blob->signature == MagickCoreSignature);
829 if (IsEventLogging() != MagickFalse)
830 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
831 blob_info=image->blob;
832 clone=MagickFalse;
833 LockSemaphoreInfo(blob_info->semaphore);
834 assert(blob_info->reference_count >= 0);
835 if (blob_info->reference_count > 1)
836 clone=MagickTrue;
837 UnlockSemaphoreInfo(blob_info->semaphore);
838 if (clone == MagickFalse)
839 return;
840 clone_info=CloneBlobInfo(blob_info);
841 DestroyBlob(image);
842 image->blob=clone_info;
843}
844␌
845/*
846%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
847% %
848% %
849% %
850+ D i s c a r d B l o b B y t e s %
851% %
852% %
853% %
854%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
855%
856% DiscardBlobBytes() discards bytes in a blob.
857%
858% The format of the DiscardBlobBytes method is:
859%
860% MagickBooleanType DiscardBlobBytes(Image *image,
861% const MagickSizeType length)
862%
863% A description of each parameter follows.
864%
865% o image: the image.
866%
867% o length: the number of bytes to skip.
868%
869*/
870MagickExport MagickBooleanType DiscardBlobBytes(Image *image,
871 const MagickSizeType length)
872{
873 MagickSizeType
874 i;
875
876 size_t
877 quantum;
878
879 ssize_t
880 count;
881
882 unsigned char
883 buffer[MagickMinBufferExtent >> 1];
884
885 assert(image != (Image *) NULL);
886 assert(image->signature == MagickCoreSignature);
887 if (length != (MagickSizeType) ((MagickOffsetType) length))
888 return(MagickFalse);
889 count=0;
890 for (i=0; i < length; i+=(MagickSizeType) count)
891 {
892 quantum=(size_t) MagickMin(length-i,sizeof(buffer));
893 (void) ReadBlobStream(image,quantum,buffer,&count);
894 if (count <= 0)
895 {
896 count=0;
897 if (errno != EINTR)
898 break;
899 }
900 }
901 return(i < (MagickSizeType) length ? MagickFalse : MagickTrue);
902}
903␌
904/*
905%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
906% %
907% %
908% %
909+ D u p l i c a t e s B l o b %
910% %
911% %
912% %
913%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
914%
915% DuplicateBlob() duplicates a blob descriptor.
916%
917% The format of the DuplicateBlob method is:
918%
919% void DuplicateBlob(Image *image,const Image *duplicate)
920%
921% A description of each parameter follows:
922%
923% o image: the image.
924%
925% o duplicate: the duplicate image.
926%
927*/
928MagickExport void DuplicateBlob(Image *image,const Image *duplicate)
929{
930 assert(image != (Image *) NULL);
931 assert(image->signature == MagickCoreSignature);
932 assert(duplicate != (Image *) NULL);
933 assert(duplicate->signature == MagickCoreSignature);
934 if (IsEventLogging() != MagickFalse)
935 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
936 DestroyBlob(image);
937 image->blob=ReferenceBlob(duplicate->blob);
938}
939␌
940/*
941%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
942% %
943% %
944% %
945+ E O F B l o b %
946% %
947% %
948% %
949%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
950%
951% EOFBlob() returns a non-zero value when EOF has been detected reading from
952% a blob or file.
953%
954% The format of the EOFBlob method is:
955%
956% int EOFBlob(const Image *image)
957%
958% A description of each parameter follows:
959%
960% o image: the image.
961%
962*/
963MagickExport int EOFBlob(const Image *image)
964{
965 BlobInfo
966 *magick_restrict blob_info;
967
968 assert(image != (Image *) NULL);
969 assert(image->signature == MagickCoreSignature);
970 assert(image->blob != (BlobInfo *) NULL);
971 assert(image->blob->type != UndefinedStream);
972 if (IsEventLogging() != MagickFalse)
973 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
974 blob_info=image->blob;
975 switch (blob_info->type)
976 {
977 case UndefinedStream:
978 case StandardStream:
979 break;
980 case FileStream:
981 case PipeStream:
982 {
983 blob_info->eof=feof(blob_info->file_info.file) != 0 ? MagickTrue :
984 MagickFalse;
985 break;
986 }
987 case ZipStream:
988 {
989#if defined(MAGICKCORE_ZLIB_DELEGATE)
990 blob_info->eof=gzeof(blob_info->file_info.gzfile) != 0 ? MagickTrue :
991 MagickFalse;
992#endif
993 break;
994 }
995 case BZipStream:
996 {
997#if defined(MAGICKCORE_BZLIB_DELEGATE)
998 int
999 status;
1000
1001 status=0;
1002 (void) BZ2_bzerror(blob_info->file_info.bzfile,&status);
1003 blob_info->eof=status == BZ_UNEXPECTED_EOF ? MagickTrue : MagickFalse;
1004#endif
1005 break;
1006 }
1007 case FifoStream:
1008 {
1009 blob_info->eof=MagickFalse;
1010 break;
1011 }
1012 case BlobStream:
1013 break;
1014 }
1015 return((int) blob_info->eof);
1016}
1017␌
1018/*
1019%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1020% %
1021% %
1022% %
1023+ E r r o r B l o b %
1024% %
1025% %
1026% %
1027%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1028%
1029% ErrorBlob() returns a non-zero value when an error has been detected reading
1030% from a blob or file.
1031%
1032% The format of the ErrorBlob method is:
1033%
1034% int ErrorBlob(const Image *image)
1035%
1036% A description of each parameter follows:
1037%
1038% o image: the image.
1039%
1040*/
1041MagickExport int ErrorBlob(const Image *image)
1042{
1043 BlobInfo
1044 *magick_restrict blob_info;
1045
1046 assert(image != (Image *) NULL);
1047 assert(image->signature == MagickCoreSignature);
1048 assert(image->blob != (BlobInfo *) NULL);
1049 assert(image->blob->type != UndefinedStream);
1050 if (IsEventLogging() != MagickFalse)
1051 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1052 blob_info=image->blob;
1053 switch (blob_info->type)
1054 {
1055 case UndefinedStream:
1056 case StandardStream:
1057 break;
1058 case FileStream:
1059 case PipeStream:
1060 {
1061 blob_info->error=ferror(blob_info->file_info.file);
1062 break;
1063 }
1064 case ZipStream:
1065 {
1066#if defined(MAGICKCORE_ZLIB_DELEGATE)
1067 (void) gzerror(blob_info->file_info.gzfile,&blob_info->error);
1068#endif
1069 break;
1070 }
1071 case BZipStream:
1072 {
1073#if defined(MAGICKCORE_BZLIB_DELEGATE)
1074 (void) BZ2_bzerror(blob_info->file_info.bzfile,&blob_info->error);
1075#endif
1076 break;
1077 }
1078 case FifoStream:
1079 {
1080 blob_info->error=0;
1081 break;
1082 }
1083 case BlobStream:
1084 break;
1085 }
1086 return(blob_info->error);
1087}
1088␌
1089/*
1090%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1091% %
1092% %
1093% %
1094% F i l e T o B l o b %
1095% %
1096% %
1097% %
1098%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1099%
1100% FileToBlob() returns the contents of a file as a buffer terminated with
1101% the '\0' character. The length of the buffer (not including the extra
1102% terminating '\0' character) is returned via the 'length' parameter. Free
1103% the buffer with RelinquishMagickMemory().
1104%
1105% The format of the FileToBlob method is:
1106%
1107% unsigned char *FileToBlob(const char *filename,const size_t extent,
1108% size_t *length,ExceptionInfo *exception)
1109%
1110% A description of each parameter follows:
1111%
1112% o blob: FileToBlob() returns the contents of a file as a blob. If
1113% an error occurs NULL is returned.
1114%
1115% o filename: the filename.
1116%
1117% o extent: The maximum length of the blob.
1118%
1119% o length: On return, this reflects the actual length of the blob.
1120%
1121% o exception: return any errors or warnings in this structure.
1122%
1123*/
1124MagickExport unsigned char *FileToBlob(const char *filename,const size_t extent,
1125 size_t *length,ExceptionInfo *exception)
1126{
1127 int
1128 file;
1129
1130 MagickBooleanType
1131 status;
1132
1133 MagickOffsetType
1134 offset;
1135
1136 size_t
1137 i;
1138
1139 ssize_t
1140 count;
1141
1142 struct stat
1143 attributes;
1144
1145 unsigned char
1146 *blob;
1147
1148 void
1149 *map;
1150
1151 assert(filename != (const char *) NULL);
1152 assert(exception != (ExceptionInfo *) NULL);
1153 assert(exception->signature == MagickCoreSignature);
1154 if (IsEventLogging() != MagickFalse)
1155 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
1156 *length=0;
1157 if (IsPathAuthorized(ReadPolicyRights,filename) == MagickFalse)
1158 {
1159 errno=EPERM;
1160 (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
1161 "NotAuthorized","`%s'",filename);
1162 return(NULL);
1163 }
1164 file=fileno(stdin);
1165 if (LocaleCompare(filename,"-") != 0)
1166 {
1167 int
1168 flags = O_RDONLY | O_BINARY;
1169
1170 status=GetPathAttributes(filename,&attributes);
1171 if ((status == MagickFalse) || (S_ISDIR(attributes.st_mode) != 0))
1172 {
1173 ThrowFileException(exception,BlobError,"UnableToReadBlob",filename);
1174 return(NULL);
1175 }
1176 file=open_utf8(filename,flags,0);
1177 }
1178 if (file == -1)
1179 {
1180 ThrowFileException(exception,BlobError,"UnableToOpenFile",filename);
1181 return((unsigned char *) NULL);
1182 }
1183 if (IsPathAuthorized(ReadPolicyRights,filename) == MagickFalse)
1184 {
1185 file=close_utf8(file)-1;
1186 errno=EPERM;
1187 (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
1188 "NotAuthorized","`%s'",filename);
1189 return(NULL);
1190 }
1191 offset=(MagickOffsetType) lseek(file,0,SEEK_END);
1192 count=0;
1193 if ((file == fileno(stdin)) || (offset < 0) ||
1194 (offset != (MagickOffsetType) ((ssize_t) offset)))
1195 {
1196 size_t
1197 quantum;
1198
1199 struct stat
1200 file_stats;
1201
1202 /*
1203 Stream is not seekable.
1204 */
1205 offset=(MagickOffsetType) lseek(file,0,SEEK_SET);
1206 quantum=(size_t) MagickMaxBufferExtent;
1207 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
1208 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
1209 blob=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*blob));
1210 for (i=0; blob != (unsigned char *) NULL; i+=count)
1211 {
1212 count=read(file,blob+i,quantum);
1213 if (count <= 0)
1214 {
1215 count=0;
1216 if (errno != EINTR)
1217 break;
1218 }
1219 if (~((size_t) i) < (count+quantum+1))
1220 {
1221 blob=(unsigned char *) RelinquishMagickMemory(blob);
1222 break;
1223 }
1224 blob=(unsigned char *) ResizeQuantumMemory(blob,i+count+quantum+1,
1225 sizeof(*blob));
1226 if ((size_t) (i+count) >= extent)
1227 break;
1228 }
1229 if (LocaleCompare(filename,"-") != 0)
1230 file=close_utf8(file);
1231 if (blob == (unsigned char *) NULL)
1232 {
1233 (void) ThrowMagickException(exception,GetMagickModule(),
1234 ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
1235 return((unsigned char *) NULL);
1236 }
1237 if (file == -1)
1238 {
1239 blob=(unsigned char *) RelinquishMagickMemory(blob);
1240 ThrowFileException(exception,BlobError,"UnableToReadBlob",filename);
1241 return((unsigned char *) NULL);
1242 }
1243 *length=(size_t) MagickMin(i+count,extent);
1244 blob[*length]='\0';
1245 return(blob);
1246 }
1247 *length=(size_t) MagickMin(offset,(MagickOffsetType)
1248 MagickMin(extent,(size_t) MAGICK_SSIZE_MAX));
1249 blob=(unsigned char *) NULL;
1250 if (~(*length) >= (MagickPathExtent-1))
1251 blob=(unsigned char *) AcquireQuantumMemory(*length+MagickPathExtent,
1252 sizeof(*blob));
1253 if (blob == (unsigned char *) NULL)
1254 {
1255 file=close_utf8(file);
1256 (void) ThrowMagickException(exception,GetMagickModule(),
1257 ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
1258 return((unsigned char *) NULL);
1259 }
1260 map=MapBlob(file,ReadMode,0,*length);
1261 if (map != (unsigned char *) NULL)
1262 {
1263 (void) memcpy(blob,map,*length);
1264 (void) UnmapBlob(map,*length);
1265 }
1266 else
1267 {
1268 (void) lseek(file,0,SEEK_SET);
1269 for (i=0; i < *length; i+=count)
1270 {
1271 count=read(file,blob+i,(size_t) MagickMin(*length-i,(size_t)
1272 MagickMaxBufferExtent));
1273 if (count <= 0)
1274 {
1275 count=0;
1276 if (errno != EINTR)
1277 break;
1278 }
1279 }
1280 if (i < *length)
1281 {
1282 file=close_utf8(file)-1;
1283 blob=(unsigned char *) RelinquishMagickMemory(blob);
1284 ThrowFileException(exception,BlobError,"UnableToReadBlob",filename);
1285 return((unsigned char *) NULL);
1286 }
1287 }
1288 blob[*length]='\0';
1289 if (LocaleCompare(filename,"-") != 0)
1290 file=close_utf8(file);
1291 if (file == -1)
1292 {
1293 blob=(unsigned char *) RelinquishMagickMemory(blob);
1294 ThrowFileException(exception,BlobError,"UnableToReadBlob",filename);
1295 }
1296 return(blob);
1297}
1298␌
1299/*
1300%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1301% %
1302% %
1303% %
1304% F i l e T o I m a g e %
1305% %
1306% %
1307% %
1308%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1309%
1310% FileToImage() write the contents of a file to an image.
1311%
1312% The format of the FileToImage method is:
1313%
1314% MagickBooleanType FileToImage(Image *,const char *filename)
1315%
1316% A description of each parameter follows:
1317%
1318% o image: the image.
1319%
1320% o filename: the filename.
1321%
1322*/
1323
1324static inline ssize_t WriteBlobStream(Image *image,const size_t length,
1325 const unsigned char *magick_restrict data)
1326{
1327 BlobInfo
1328 *magick_restrict blob_info;
1329
1330 MagickSizeType
1331 extent;
1332
1333 unsigned char
1334 *magick_restrict q;
1335
1336 assert(image->blob != (BlobInfo *) NULL);
1337 assert(image->blob->type != UndefinedStream);
1338 assert(data != (void *) NULL);
1339 blob_info=image->blob;
1340 if (blob_info->type != BlobStream)
1341 return(WriteBlob(image,length,data));
1342 if (blob_info->offset > (MagickOffsetType) (MAGICK_SSIZE_MAX-length))
1343 {
1344 errno=EOVERFLOW;
1345 return(0);
1346 }
1347 extent=(MagickSizeType) (blob_info->offset+(MagickOffsetType) length);
1348 if (extent >= blob_info->extent)
1349 {
1350 extent+=blob_info->quantum+length;
1351 blob_info->quantum<<=1;
1352 if (SetBlobExtent(image,extent) == MagickFalse)
1353 return(0);
1354 }
1355 q=blob_info->data+blob_info->offset;
1356 (void) memcpy(q,data,length);
1357 blob_info->offset+=length;
1358 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
1359 blob_info->length=(size_t) blob_info->offset;
1360 return((ssize_t) length);
1361}
1362
1363MagickExport MagickBooleanType FileToImage(Image *image,const char *filename)
1364{
1365 int
1366 file;
1367
1368 size_t
1369 length,
1370 quantum;
1371
1372 ssize_t
1373 count;
1374
1375 struct stat
1376 file_stats;
1377
1378 unsigned char
1379 *blob;
1380
1381 assert(image != (const Image *) NULL);
1382 assert(image->signature == MagickCoreSignature);
1383 assert(filename != (const char *) NULL);
1384 if (IsEventLogging() != MagickFalse)
1385 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
1386 if (IsPathAuthorized(ReadPolicyRights,filename) == MagickFalse)
1387 {
1388 errno=EPERM;
1389 (void) ThrowMagickException(&image->exception,GetMagickModule(),
1390 PolicyError,"NotAuthorized","`%s'",filename);
1391 return(MagickFalse);
1392 }
1393 file=fileno(stdin);
1394 if (LocaleCompare(filename,"-") != 0)
1395 {
1396 int
1397 flags = O_RDONLY | O_BINARY;
1398
1399 file=open_utf8(filename,flags,0);
1400 }
1401 if (file == -1)
1402 {
1403 ThrowFileException(&image->exception,BlobError,"UnableToOpenBlob",
1404 filename);
1405 return(MagickFalse);
1406 }
1407 if (IsPathAuthorized(ReadPolicyRights,filename) == MagickFalse)
1408 {
1409 errno=EPERM;
1410 (void) ThrowMagickException(&image->exception,GetMagickModule(),
1411 PolicyError,"NotAuthorized","`%s'",filename);
1412 return(MagickFalse);
1413 }
1414 quantum=(size_t) MagickMaxBufferExtent;
1415 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
1416 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
1417 blob=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*blob));
1418 if (blob == (unsigned char *) NULL)
1419 {
1420 file=close_utf8(file);
1421 ThrowFileException(&image->exception,ResourceLimitError,
1422 "MemoryAllocationFailed",filename);
1423 return(MagickFalse);
1424 }
1425 for ( ; ; )
1426 {
1427 count=read(file,blob,quantum);
1428 if (count <= 0)
1429 {
1430 count=0;
1431 if (errno != EINTR)
1432 break;
1433 }
1434 length=(size_t) count;
1435 count=WriteBlobStream(image,length,blob);
1436 if (count != (ssize_t) length)
1437 {
1438 ThrowFileException(&image->exception,BlobError,"UnableToWriteBlob",
1439 filename);
1440 break;
1441 }
1442 }
1443 file=close_utf8(file);
1444 if (file == -1)
1445 ThrowFileException(&image->exception,BlobError,"UnableToWriteBlob",
1446 filename);
1447 blob=(unsigned char *) RelinquishMagickMemory(blob);
1448 return(MagickTrue);
1449}
1450␌
1451/*
1452%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1453% %
1454% %
1455% %
1456+ G e t B l o b E r r o r %
1457% %
1458% %
1459% %
1460%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1461%
1462% GetBlobError() returns MagickTrue if the blob associated with the specified
1463% image encountered an error.
1464%
1465% The format of the GetBlobError method is:
1466%
1467% MagickBooleanType GetBlobError(const Image *image)
1468%
1469% A description of each parameter follows:
1470%
1471% o image: the image.
1472%
1473*/
1474MagickExport MagickBooleanType GetBlobError(const Image *image)
1475{
1476 assert(image != (const Image *) NULL);
1477 assert(image->signature == MagickCoreSignature);
1478 if (IsEventLogging() != MagickFalse)
1479 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1480 if ((image->blob->status != 0) && (image->blob->error_number != 0))
1481 errno=image->blob->error_number;
1482 return(image->blob->status == 0 ? MagickFalse : MagickTrue);
1483}
1484␌
1485/*
1486%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1487% %
1488% %
1489% %
1490+ G e t B l o b F i l e H a n d l e %
1491% %
1492% %
1493% %
1494%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1495%
1496% GetBlobFileHandle() returns the file handle associated with the image blob.
1497%
1498% The format of the GetBlobFile method is:
1499%
1500% FILE *GetBlobFileHandle(const Image *image)
1501%
1502% A description of each parameter follows:
1503%
1504% o image: the image.
1505%
1506*/
1507MagickExport FILE *GetBlobFileHandle(const Image *image)
1508{
1509 assert(image != (const Image *) NULL);
1510 assert(image->signature == MagickCoreSignature);
1511 return(image->blob->file_info.file);
1512}
1513␌
1514/*
1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1516% %
1517% %
1518% %
1519+ G e t B l o b I n f o %
1520% %
1521% %
1522% %
1523%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1524%
1525% GetBlobInfo() initializes the BlobInfo structure.
1526%
1527% The format of the GetBlobInfo method is:
1528%
1529% void GetBlobInfo(BlobInfo *blob_info)
1530%
1531% A description of each parameter follows:
1532%
1533% o blob_info: Specifies a pointer to a BlobInfo structure.
1534%
1535*/
1536MagickExport void GetBlobInfo(BlobInfo *blob_info)
1537{
1538 assert(blob_info != (BlobInfo *) NULL);
1539 (void) memset(blob_info,0,sizeof(*blob_info));
1540 blob_info->type=UndefinedStream;
1541 blob_info->quantum=(size_t) MagickMaxBlobExtent;
1542 blob_info->properties.st_mtime=GetMagickTime();
1543 blob_info->properties.st_ctime=blob_info->properties.st_mtime;
1544 blob_info->debug=GetLogEventMask() & BlobEvent ? MagickTrue : MagickFalse;
1545 blob_info->reference_count=1;
1546 blob_info->semaphore=AllocateSemaphoreInfo();
1547 blob_info->signature=MagickCoreSignature;
1548}
1549␌
1550/*
1551%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1552% %
1553% %
1554% %
1555% G e t B l o b P r o p e r t i e s %
1556% %
1557% %
1558% %
1559%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1560%
1561% GetBlobProperties() returns information about an image blob.
1562%
1563% The format of the GetBlobProperties method is:
1564%
1565% const struct stat *GetBlobProperties(const Image *image)
1566%
1567% A description of each parameter follows:
1568%
1569% o image: the image.
1570%
1571*/
1572MagickExport const struct stat *GetBlobProperties(const Image *image)
1573{
1574 assert(image != (Image *) NULL);
1575 assert(image->signature == MagickCoreSignature);
1576 if (IsEventLogging() != MagickFalse)
1577 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1578 return(&image->blob->properties);
1579}
1580␌
1581/*
1582%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1583% %
1584% %
1585% %
1586+ G e t B l o b S i z e %
1587% %
1588% %
1589% %
1590%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1591%
1592% GetBlobSize() returns the current length of the image file or blob; zero is
1593% returned if the size cannot be determined.
1594%
1595% The format of the GetBlobSize method is:
1596%
1597% MagickSizeType GetBlobSize(const Image *image)
1598%
1599% A description of each parameter follows:
1600%
1601% o image: the image.
1602%
1603*/
1604MagickExport MagickSizeType GetBlobSize(const Image *image)
1605{
1606 BlobInfo
1607 *magick_restrict blob_info;
1608
1609 MagickSizeType
1610 extent;
1611
1612 assert(image != (Image *) NULL);
1613 assert(image->signature == MagickCoreSignature);
1614 assert(image->blob != (BlobInfo *) NULL);
1615 if (IsEventLogging() != MagickFalse)
1616 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1617 blob_info=image->blob;
1618 extent=0;
1619 switch (blob_info->type)
1620 {
1621 case UndefinedStream:
1622 case StandardStream:
1623 {
1624 extent=blob_info->size;
1625 break;
1626 }
1627 case FileStream:
1628 {
1629 int
1630 file_descriptor;
1631
1632 extent=(MagickSizeType) blob_info->properties.st_size;
1633 if (extent == 0)
1634 extent=blob_info->size;
1635 file_descriptor=fileno(blob_info->file_info.file);
1636 if (file_descriptor == -1)
1637 break;
1638 if (fstat(file_descriptor,&blob_info->properties) == 0)
1639 extent=(MagickSizeType) blob_info->properties.st_size;
1640 break;
1641 }
1642 case PipeStream:
1643 {
1644 extent=blob_info->size;
1645 break;
1646 }
1647 case ZipStream:
1648 case BZipStream:
1649 {
1650 MagickBooleanType
1651 status;
1652
1653 status=GetPathAttributes(image->filename,&blob_info->properties);
1654 if (status != MagickFalse)
1655 extent=(MagickSizeType) blob_info->properties.st_size;
1656 break;
1657 }
1658 case FifoStream:
1659 break;
1660 case BlobStream:
1661 {
1662 extent=(MagickSizeType) blob_info->length;
1663 break;
1664 }
1665 }
1666 return(extent);
1667}
1668␌
1669/*
1670%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1671% %
1672% %
1673% %
1674+ G e t B l o b S t r e a m D a t a %
1675% %
1676% %
1677% %
1678%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1679%
1680% GetBlobStreamData() returns the stream data for the image.
1681%
1682% The format of the GetBlobStreamData method is:
1683%
1684% unsigned char *GetBlobStreamData(const Image *image)
1685%
1686% A description of each parameter follows:
1687%
1688% o image: the image.
1689%
1690*/
1691MagickExport unsigned char *GetBlobStreamData(const Image *image)
1692{
1693 assert(image != (const Image *) NULL);
1694 assert(image->signature == MagickCoreSignature);
1695 return(image->blob->data);
1696}
1697␌
1698/*
1699%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1700% %
1701% %
1702% %
1703+ G e t B l o b S t r e a m H a n d l e r %
1704% %
1705% %
1706% %
1707%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1708%
1709% GetBlobStreamHandler() returns the stream handler for the image.
1710%
1711% The format of the GetBlobStreamHandler method is:
1712%
1713% StreamHandler GetBlobStreamHandler(const Image *image)
1714%
1715% A description of each parameter follows:
1716%
1717% o image: the image.
1718%
1719*/
1720MagickExport StreamHandler GetBlobStreamHandler(const Image *image)
1721{
1722 assert(image != (const Image *) NULL);
1723 assert(image->signature == MagickCoreSignature);
1724 if (IsEventLogging() != MagickFalse)
1725 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1726 return(image->blob->stream);
1727}
1728␌
1729/*
1730%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1731% %
1732% %
1733% %
1734% I m a g e T o B l o b %
1735% %
1736% %
1737% %
1738%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1739%
1740% ImageToBlob() implements direct to memory image formats. It returns the
1741% image as a formatted blob and its length. The magick member of the Image
1742% structure determines the format of the returned blob (GIF, JPEG, PNG,
1743% etc.). This method is the equivalent of WriteImage(), but writes the
1744% formatted "file" to a memory buffer rather than to an actual file.
1745%
1746% The format of the ImageToBlob method is:
1747%
1748% unsigned char *ImageToBlob(const ImageInfo *image_info,Image *image,
1749% size_t *length,ExceptionInfo *exception)
1750%
1751% A description of each parameter follows:
1752%
1753% o image_info: the image info.
1754%
1755% o image: the image.
1756%
1757% o length: return the actual length of the blob.
1758%
1759% o exception: return any errors or warnings in this structure.
1760%
1761*/
1762MagickExport unsigned char *ImageToBlob(const ImageInfo *image_info,
1763 Image *image,size_t *length,ExceptionInfo *exception)
1764{
1765 const MagickInfo
1766 *magick_info;
1767
1768 ImageInfo
1769 *blob_info;
1770
1771 MagickBooleanType
1772 status;
1773
1774 unsigned char
1775 *blob;
1776
1777 assert(image_info != (const ImageInfo *) NULL);
1778 assert(image_info->signature == MagickCoreSignature);
1779 assert(image != (Image *) NULL);
1780 assert(image->signature == MagickCoreSignature);
1781 assert(exception != (ExceptionInfo *) NULL);
1782 assert(exception->signature == MagickCoreSignature);
1783 if (IsEventLogging() != MagickFalse)
1784 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1785 image_info->filename);
1786 *length=0;
1787 blob=(unsigned char *) NULL;
1788 blob_info=CloneImageInfo(image_info);
1789 blob_info->adjoin=MagickFalse;
1790 (void) SetImageInfo(blob_info,1,exception);
1791 if (*blob_info->magick != '\0')
1792 (void) CopyMagickString(image->magick,blob_info->magick,MagickPathExtent);
1793 magick_info=GetMagickInfo(image->magick,exception);
1794 if (magick_info == (const MagickInfo *) NULL)
1795 {
1796 (void) ThrowMagickException(exception,GetMagickModule(),
1797 MissingDelegateError,"NoEncodeDelegateForThisImageFormat","`%s'",
1798 image->magick);
1799 blob_info=DestroyImageInfo(blob_info);
1800 return(blob);
1801 }
1802 (void) CopyMagickString(blob_info->magick,image->magick,MagickPathExtent);
1803 if (GetMagickBlobSupport(magick_info) != MagickFalse)
1804 {
1805 /*
1806 Native blob support for this image format.
1807 */
1808 blob_info->length=0;
1809 blob_info->blob=AcquireQuantumMemory(MagickMaxBlobExtent,
1810 sizeof(unsigned char));
1811 if (blob_info->blob == NULL)
1812 (void) ThrowMagickException(exception,GetMagickModule(),
1813 ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
1814 else
1815 {
1816 (void) CloseBlob(image);
1817 image->blob->exempt=MagickTrue;
1818 *image->filename='\0';
1819 status=WriteImage(blob_info,image);
1820 InheritException(exception,&image->exception);
1821 *length=image->blob->length;
1822 blob=DetachBlob(image->blob);
1823 if (blob != (void *) NULL)
1824 {
1825 if (status == MagickFalse)
1826 blob=(unsigned char *) RelinquishMagickMemory(blob);
1827 else
1828 blob=(unsigned char *) ResizeQuantumMemory(blob,*length+1,
1829 sizeof(unsigned char));
1830 }
1831 else if (status == MagickFalse)
1832 blob_info->blob=RelinquishMagickMemory(blob_info->blob);
1833 }
1834 }
1835 else
1836 {
1837 char
1838 unique[MagickPathExtent];
1839
1840 int
1841 file;
1842
1843 /*
1844 Write file to disk in blob image format.
1845 */
1846 file=AcquireUniqueFileResource(unique);
1847 if (file == -1)
1848 {
1849 ThrowFileException(exception,BlobError,"UnableToWriteBlob",
1850 image_info->filename);
1851 }
1852 else
1853 {
1854 blob_info->file=fdopen(file,"wb");
1855 if (blob_info->file != (FILE *) NULL)
1856 {
1857 (void) FormatLocaleString(image->filename,MagickPathExtent,
1858 "%s:%s",image->magick,unique);
1859 status=WriteImage(blob_info,image);
1860 (void) fclose(blob_info->file);
1861 if (status == MagickFalse)
1862 InheritException(exception,&image->exception);
1863 else
1864 blob=FileToBlob(unique,SIZE_MAX,length,exception);
1865 }
1866 (void) RelinquishUniqueFileResource(unique);
1867 }
1868 }
1869 blob_info=DestroyImageInfo(blob_info);
1870 return(blob);
1871}
1872␌
1873/*
1874%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1875% %
1876% %
1877% %
1878% I m a g e T o F i l e %
1879% %
1880% %
1881% %
1882%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1883%
1884% ImageToFile() writes an image to a file. It returns MagickFalse if an error
1885% occurs otherwise MagickTrue.
1886%
1887% The format of the ImageToFile method is:
1888%
1889% MagickBooleanType ImageToFile(Image *image,char *filename,
1890% ExceptionInfo *exception)
1891%
1892% A description of each parameter follows:
1893%
1894% o image: the image.
1895%
1896% o filename: Write the image to this file.
1897%
1898% o exception: return any errors or warnings in this structure.
1899%
1900*/
1901MagickExport MagickBooleanType ImageToFile(Image *image,char *filename,
1902 ExceptionInfo *exception)
1903{
1904 int
1905 file;
1906
1907 const unsigned char
1908 *p;
1909
1910 size_t
1911 i;
1912
1913 size_t
1914 length,
1915 quantum;
1916
1917 ssize_t
1918 count;
1919
1920 struct stat
1921 file_stats;
1922
1923 unsigned char
1924 *buffer;
1925
1926 assert(image != (Image *) NULL);
1927 assert(image->signature == MagickCoreSignature);
1928 assert(image->blob != (BlobInfo *) NULL);
1929 assert(image->blob->type != UndefinedStream);
1930 assert(filename != (const char *) NULL);
1931 if (IsEventLogging() != MagickFalse)
1932 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
1933 if (*filename == '\0')
1934 file=AcquireUniqueFileResource(filename);
1935 else
1936 if (LocaleCompare(filename,"-") == 0)
1937 file=fileno(stdout);
1938 else
1939 file=open_utf8(filename,O_RDWR | O_CREAT | O_EXCL | O_BINARY,P_MODE);
1940 if (file == -1)
1941 {
1942 ThrowFileException(exception,BlobError,"UnableToWriteBlob",filename);
1943 return(MagickFalse);
1944 }
1945 quantum=(size_t) MagickMaxBufferExtent;
1946 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
1947 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
1948 buffer=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*buffer));
1949 if (buffer == (unsigned char *) NULL)
1950 {
1951 file=close_utf8(file)-1;
1952 (void) ThrowMagickException(exception,GetMagickModule(),
1953 ResourceLimitError,"MemoryAllocationError","`%s'",filename);
1954 return(MagickFalse);
1955 }
1956 length=0;
1957 p=(const unsigned char *) ReadBlobStream(image,quantum,buffer,&count);
1958 for (i=0; count > 0; )
1959 {
1960 length=(size_t) count;
1961 for (i=0; i < length; i+=count)
1962 {
1963 count=write(file,p+i,(size_t) (length-i));
1964 if (count <= 0)
1965 {
1966 count=0;
1967 if (errno != EINTR)
1968 break;
1969 }
1970 }
1971 if (i < length)
1972 break;
1973 p=(const unsigned char *) ReadBlobStream(image,quantum,buffer,&count);
1974 }
1975 if (LocaleCompare(filename,"-") != 0)
1976 file=close_utf8(file);
1977 buffer=(unsigned char *) RelinquishMagickMemory(buffer);
1978 if ((file == -1) || (i < length))
1979 {
1980 if (file != -1)
1981 file=close_utf8(file);
1982 ThrowFileException(exception,BlobError,"UnableToWriteBlob",filename);
1983 return(MagickFalse);
1984 }
1985 return(MagickTrue);
1986}
1987␌
1988/*
1989%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1990% %
1991% %
1992% %
1993% I m a g e s T o B l o b %
1994% %
1995% %
1996% %
1997%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1998%
1999% ImagesToBlob() implements direct to memory image formats. It returns the
2000% image sequence as a blob and its length. The magick member of the ImageInfo
2001% structure determines the format of the returned blob (GIF, JPEG, PNG, etc.)
2002%
2003% Note, some image formats do not permit multiple images to the same image
2004% stream (e.g. JPEG). in this instance, just the first image of the
2005% sequence is returned as a blob.
2006%
2007% The format of the ImagesToBlob method is:
2008%
2009% unsigned char *ImagesToBlob(const ImageInfo *image_info,Image *images,
2010% size_t *length,ExceptionInfo *exception)
2011%
2012% A description of each parameter follows:
2013%
2014% o image_info: the image info.
2015%
2016% o images: the image list.
2017%
2018% o length: return the actual length of the blob.
2019%
2020% o exception: return any errors or warnings in this structure.
2021%
2022*/
2023MagickExport unsigned char *ImagesToBlob(const ImageInfo *image_info,
2024 Image *images,size_t *length,ExceptionInfo *exception)
2025{
2026 const MagickInfo
2027 *magick_info;
2028
2029 ImageInfo
2030 *blob_info;
2031
2032 MagickBooleanType
2033 status;
2034
2035 unsigned char
2036 *blob;
2037
2038 assert(image_info != (const ImageInfo *) NULL);
2039 assert(image_info->signature == MagickCoreSignature);
2040 assert(images != (Image *) NULL);
2041 assert(images->signature == MagickCoreSignature);
2042 assert(exception != (ExceptionInfo *) NULL);
2043 if (IsEventLogging() != MagickFalse)
2044 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2045 image_info->filename);
2046 *length=0;
2047 blob=(unsigned char *) NULL;
2048 blob_info=CloneImageInfo(image_info);
2049 (void) SetImageInfo(blob_info,(unsigned int) GetImageListLength(images),
2050 exception);
2051 if (*blob_info->magick != '\0')
2052 (void) CopyMagickString(images->magick,blob_info->magick,MagickPathExtent);
2053 magick_info=GetMagickInfo(images->magick,exception);
2054 if (magick_info == (const MagickInfo *) NULL)
2055 {
2056 (void) ThrowMagickException(exception,GetMagickModule(),
2057 MissingDelegateError,"NoEncodeDelegateForThisImageFormat","`%s'",
2058 images->magick);
2059 blob_info=DestroyImageInfo(blob_info);
2060 return(blob);
2061 }
2062 if (GetMagickAdjoin(magick_info) == MagickFalse)
2063 {
2064 blob_info=DestroyImageInfo(blob_info);
2065 return(ImageToBlob(image_info,images,length,exception));
2066 }
2067 (void) CopyMagickString(blob_info->magick,images->magick,MagickPathExtent);
2068 if (GetMagickBlobSupport(magick_info) != MagickFalse)
2069 {
2070 /*
2071 Native blob support for this images format.
2072 */
2073 blob_info->length=0;
2074 blob_info->blob=(void *) AcquireQuantumMemory(MagickMaxBlobExtent,
2075 sizeof(unsigned char));
2076 if (blob_info->blob == (void *) NULL)
2077 (void) ThrowMagickException(exception,GetMagickModule(),
2078 ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
2079 else
2080 {
2081 (void) CloseBlob(images);
2082 images->blob->exempt=MagickTrue;
2083 *images->filename='\0';
2084 status=WriteImages(blob_info,images,images->filename,exception);
2085 *length=images->blob->length;
2086 blob=DetachBlob(images->blob);
2087 if (blob != (void *) NULL)
2088 {
2089 if (status == MagickFalse)
2090 blob=(unsigned char *) RelinquishMagickMemory(blob);
2091 else
2092 blob=(unsigned char *) ResizeQuantumMemory(blob,*length+1,
2093 sizeof(unsigned char));
2094 }
2095 else
2096 if (status == MagickFalse)
2097 blob_info->blob=RelinquishMagickMemory(blob_info->blob);
2098 }
2099 }
2100 else
2101 {
2102 char
2103 filename[MagickPathExtent],
2104 unique[MagickPathExtent];
2105
2106 int
2107 file;
2108
2109 /*
2110 Write file to disk in blob images format.
2111 */
2112 file=AcquireUniqueFileResource(unique);
2113 if (file == -1)
2114 {
2115 ThrowFileException(exception,FileOpenError,"UnableToWriteBlob",
2116 image_info->filename);
2117 }
2118 else
2119 {
2120 blob_info->file=fdopen(file,"wb");
2121 if (blob_info->file != (FILE *) NULL)
2122 {
2123 (void) FormatLocaleString(filename,MagickPathExtent,"%s:%s",
2124 images->magick,unique);
2125 status=WriteImages(blob_info,images,filename,exception);
2126 (void) fclose(blob_info->file);
2127 if (status == MagickFalse)
2128 InheritException(exception,&images->exception);
2129 else
2130 blob=FileToBlob(unique,SIZE_MAX,length,exception);
2131 }
2132 (void) RelinquishUniqueFileResource(unique);
2133 }
2134 }
2135 blob_info=DestroyImageInfo(blob_info);
2136 return(blob);
2137}
2138/*
2139%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2140% %
2141% %
2142% %
2143% I n j e c t I m a g e B l o b %
2144% %
2145% %
2146% %
2147%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2148%
2149% InjectImageBlob() injects the image with a copy of itself in the specified
2150% format (e.g. inject JPEG into a PDF image).
2151%
2152% The format of the InjectImageBlob method is:
2153%
2154% MagickBooleanType InjectImageBlob(const ImageInfo *image_info,
2155% Image *image,Image *inject_image,const char *format,
2156% ExceptionInfo *exception)
2157%
2158% A description of each parameter follows:
2159%
2160% o image_info: the image info..
2161%
2162% o image: the image.
2163%
2164% o inject_image: inject into the image stream.
2165%
2166% o format: the image format.
2167%
2168% o exception: return any errors or warnings in this structure.
2169%
2170*/
2171MagickExport MagickBooleanType InjectImageBlob(const ImageInfo *image_info,
2172 Image *image,Image *inject_image,const char *format,ExceptionInfo *exception)
2173{
2174 char
2175 filename[MagickPathExtent];
2176
2177 FILE
2178 *unique_file;
2179
2180 Image
2181 *byte_image;
2182
2183 ImageInfo
2184 *write_info;
2185
2186 int
2187 file;
2188
2189 MagickBooleanType
2190 status;
2191
2192 size_t
2193 quantum;
2194
2195 struct stat
2196 file_stats;
2197
2198 unsigned char
2199 *buffer;
2200
2201 /*
2202 Write inject image to a temporary file.
2203 */
2204 assert(image_info != (ImageInfo *) NULL);
2205 assert(image_info->signature == MagickCoreSignature);
2206 assert(image != (Image *) NULL);
2207 assert(image->signature == MagickCoreSignature);
2208 assert(inject_image != (Image *) NULL);
2209 assert(inject_image->signature == MagickCoreSignature);
2210 assert(exception != (ExceptionInfo *) NULL);
2211 if (IsEventLogging() != MagickFalse)
2212 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2213 unique_file=(FILE *) NULL;
2214 file=AcquireUniqueFileResource(filename);
2215 if (file != -1)
2216 unique_file=fdopen(file,"wb");
2217 if ((file == -1) || (unique_file == (FILE *) NULL))
2218 {
2219 (void) CopyMagickString(image->filename,filename,MagickPathExtent);
2220 ThrowFileException(exception,FileOpenError,"UnableToCreateTemporaryFile",
2221 image->filename);
2222 return(MagickFalse);
2223 }
2224 byte_image=CloneImage(inject_image,0,0,MagickFalse,exception);
2225 if (byte_image == (Image *) NULL)
2226 {
2227 (void) fclose(unique_file);
2228 (void) RelinquishUniqueFileResource(filename);
2229 return(MagickFalse);
2230 }
2231 (void) FormatLocaleString(byte_image->filename,MagickPathExtent,"%s:%s",
2232 format,filename);
2233 DestroyBlob(byte_image);
2234 byte_image->blob=CloneBlobInfo((BlobInfo *) NULL);
2235 write_info=CloneImageInfo(image_info);
2236 SetImageInfoFile(write_info,unique_file);
2237 status=WriteImage(write_info,byte_image);
2238 write_info=DestroyImageInfo(write_info);
2239 byte_image=DestroyImage(byte_image);
2240 (void) fclose(unique_file);
2241 if (status == MagickFalse)
2242 {
2243 (void) RelinquishUniqueFileResource(filename);
2244 return(MagickFalse);
2245 }
2246 /*
2247 Inject into image stream.
2248 */
2249 file=open_utf8(filename,O_RDONLY | O_BINARY,0);
2250 if (file == -1)
2251 {
2252 (void) RelinquishUniqueFileResource(filename);
2253 ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
2254 image_info->filename);
2255 return(MagickFalse);
2256 }
2257 quantum=(size_t) MagickMaxBufferExtent;
2258 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
2259 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
2260 buffer=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*buffer));
2261 if (buffer == (unsigned char *) NULL)
2262 {
2263 (void) RelinquishUniqueFileResource(filename);
2264 file=close_utf8(file);
2265 ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
2266 image->filename);
2267 }
2268 for ( ; ; )
2269 {
2270 ssize_t count = read(file,buffer,quantum);
2271 if (count <= 0)
2272 {
2273 count=0;
2274 if (errno != EINTR)
2275 break;
2276 }
2277 status=WriteBlobStream(image,(size_t) count,buffer) == count ? MagickTrue :
2278 MagickFalse;
2279 }
2280 file=close_utf8(file);
2281 if (file == -1)
2282 ThrowFileException(exception,FileOpenError,"UnableToWriteBlob",filename);
2283 (void) RelinquishUniqueFileResource(filename);
2284 buffer=(unsigned char *) RelinquishMagickMemory(buffer);
2285 return(status);
2286}
2287␌
2288/*
2289%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2290% %
2291% %
2292% %
2293% I s B l o b E x e m p t %
2294% %
2295% %
2296% %
2297%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2298%
2299% IsBlobExempt() returns true if the blob is exempt.
2300%
2301% The format of the IsBlobExempt method is:
2302%
2303% MagickBooleanType IsBlobExempt(const Image *image)
2304%
2305% A description of each parameter follows:
2306%
2307% o image: the image.
2308%
2309*/
2310MagickExport MagickBooleanType IsBlobExempt(const Image *image)
2311{
2312 assert(image != (const Image *) NULL);
2313 assert(image->signature == MagickCoreSignature);
2314 if (IsEventLogging() != MagickFalse)
2315 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2316 return(image->blob->exempt);
2317}
2318␌
2319/*
2320%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2321% %
2322% %
2323% %
2324+ I s B l o b S e e k a b l e %
2325% %
2326% %
2327% %
2328%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2329%
2330% IsBlobSeekable() returns true if the blob is seekable.
2331%
2332% The format of the IsBlobSeekable method is:
2333%
2334% MagickBooleanType IsBlobSeekable(const Image *image)
2335%
2336% A description of each parameter follows:
2337%
2338% o image: the image.
2339%
2340*/
2341MagickExport MagickBooleanType IsBlobSeekable(const Image *image)
2342{
2343 BlobInfo
2344 *magick_restrict blob_info;
2345
2346 assert(image != (const Image *) NULL);
2347 assert(image->signature == MagickCoreSignature);
2348 if (IsEventLogging() != MagickFalse)
2349 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2350 blob_info=image->blob;
2351 switch (blob_info->type)
2352 {
2353 case BlobStream:
2354 return(MagickTrue);
2355 case FileStream:
2356 {
2357 int
2358 status;
2359
2360 if (blob_info->file_info.file == (FILE *) NULL)
2361 return(MagickFalse);
2362 status=fseek(blob_info->file_info.file,0,SEEK_CUR);
2363 return(status == -1 ? MagickFalse : MagickTrue);
2364 }
2365 case ZipStream:
2366 {
2367#if defined(MAGICKCORE_ZLIB_DELEGATE)
2368 MagickOffsetType
2369 offset;
2370
2371 if (blob_info->file_info.gzfile == (gzFile) NULL)
2372 return(MagickFalse);
2373 offset=gzseek(blob_info->file_info.gzfile,0,SEEK_CUR);
2374 return(offset < 0 ? MagickFalse : MagickTrue);
2375#else
2376 break;
2377#endif
2378 }
2379 case UndefinedStream:
2380 case BZipStream:
2381 case FifoStream:
2382 case PipeStream:
2383 case StandardStream:
2384 break;
2385 default:
2386 break;
2387 }
2388 return(MagickFalse);
2389}
2390␌
2391/*
2392%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2393% %
2394% %
2395% %
2396% I s B l o b T e m p o r a r y %
2397% %
2398% %
2399% %
2400%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2401%
2402% IsBlobTemporary() returns true if the blob is temporary.
2403%
2404% The format of the IsBlobTemporary method is:
2405%
2406% MagickBooleanType IsBlobTemporary(const Image *image)
2407%
2408% A description of each parameter follows:
2409%
2410% o image: the image.
2411%
2412*/
2413MagickExport MagickBooleanType IsBlobTemporary(const Image *image)
2414{
2415 assert(image != (const Image *) NULL);
2416 assert(image->signature == MagickCoreSignature);
2417 if (IsEventLogging() != MagickFalse)
2418 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2419 return(image->blob->temporary);
2420}
2421␌
2422/*
2423%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2424% %
2425% %
2426% %
2427+ M a p B l o b %
2428% %
2429% %
2430% %
2431%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2432%
2433% MapBlob() creates a mapping from a file to a binary large object.
2434%
2435% The format of the MapBlob method is:
2436%
2437% unsigned char *MapBlob(int file,const MapMode mode,
2438% const MagickOffsetType offset,const size_t length)
2439%
2440% A description of each parameter follows:
2441%
2442% o file: map this file descriptor.
2443%
2444% o mode: ReadMode, WriteMode, or IOMode.
2445%
2446% o offset: starting at this offset within the file.
2447%
2448% o length: the length of the mapping is returned in this pointer.
2449%
2450*/
2451MagickExport unsigned char *MapBlob(int file,const MapMode mode,
2452 const MagickOffsetType offset,const size_t length)
2453{
2454#if defined(MAGICKCORE_HAVE_MMAP)
2455 int
2456 flags,
2457 protection;
2458
2459 unsigned char
2460 *map;
2461
2462 /*
2463 Map file.
2464 */
2465 flags=0;
2466 if (file == -1)
2467#if defined(MAP_ANONYMOUS)
2468 flags|=MAP_ANONYMOUS;
2469#else
2470 return((unsigned char *) NULL);
2471#endif
2472 switch (mode)
2473 {
2474 case ReadMode:
2475 default:
2476 {
2477 protection=PROT_READ;
2478 flags|=MAP_PRIVATE;
2479 break;
2480 }
2481 case WriteMode:
2482 {
2483 protection=PROT_WRITE;
2484 flags|=MAP_SHARED;
2485 break;
2486 }
2487 case IOMode:
2488 {
2489 protection=PROT_READ | PROT_WRITE;
2490 flags|=MAP_SHARED;
2491 break;
2492 }
2493 }
2494#if !defined(MAGICKCORE_HAVE_HUGEPAGES) || !defined(MAP_HUGETLB)
2495 map=(unsigned char *) mmap((char *) NULL,length,protection,flags,file,offset);
2496#else
2497 map=(unsigned char *) mmap((char *) NULL,length,protection,flags |
2498 MAP_HUGETLB,file,offset);
2499 if (map == (unsigned char *) MAP_FAILED)
2500 map=(unsigned char *) mmap((char *) NULL,length,protection,flags,file,
2501 offset);
2502#endif
2503 if (map == (unsigned char *) MAP_FAILED)
2504 return((unsigned char *) NULL);
2505 return(map);
2506#else
2507 (void) file;
2508 (void) mode;
2509 (void) offset;
2510 (void) length;
2511 return((unsigned char *) NULL);
2512#endif
2513}
2514␌
2515/*
2516%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2517% %
2518% %
2519% %
2520+ M S B O r d e r L o n g %
2521% %
2522% %
2523% %
2524%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2525%
2526% MSBOrderLong() converts a least-significant byte first buffer of integers to
2527% most-significant byte first.
2528%
2529% The format of the MSBOrderLong method is:
2530%
2531% void MSBOrderLong(unsigned char *buffer,const size_t length)
2532%
2533% A description of each parameter follows.
2534%
2535% o buffer: Specifies a pointer to a buffer of integers.
2536%
2537% o length: Specifies the length of the buffer.
2538%
2539*/
2540MagickExport void MSBOrderLong(unsigned char *buffer,const size_t length)
2541{
2542 int
2543 c;
2544
2545 unsigned char
2546 *p,
2547 *q;
2548
2549 assert(buffer != (unsigned char *) NULL);
2550 q=buffer+length;
2551 while (buffer < q)
2552 {
2553 p=buffer+3;
2554 c=(int) (*p);
2555 *p=(*buffer);
2556 *buffer++=(unsigned char) c;
2557 p=buffer+1;
2558 c=(int) (*p);
2559 *p=(*buffer);
2560 *buffer++=(unsigned char) c;
2561 buffer+=2;
2562 }
2563}
2564␌
2565/*
2566%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2567% %
2568% %
2569% %
2570+ M S B O r d e r S h o r t %
2571% %
2572% %
2573% %
2574%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2575%
2576% MSBOrderShort() converts a least-significant byte first buffer of integers
2577% to most-significant byte first.
2578%
2579% The format of the MSBOrderShort method is:
2580%
2581% void MSBOrderShort(unsigned char *p,const size_t length)
2582%
2583% A description of each parameter follows.
2584%
2585% o p: Specifies a pointer to a buffer of integers.
2586%
2587% o length: Specifies the length of the buffer.
2588%
2589*/
2590MagickExport void MSBOrderShort(unsigned char *p,const size_t length)
2591{
2592 int
2593 c;
2594
2595 unsigned char
2596 *q;
2597
2598 assert(p != (unsigned char *) NULL);
2599 q=p+length;
2600 while (p < q)
2601 {
2602 c=(int) (*p);
2603 *p=(*(p+1));
2604 p++;
2605 *p++=(unsigned char) c;
2606 }
2607}
2608␌
2609/*
2610%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2611% %
2612% %
2613% %
2614+ O p e n B l o b %
2615% %
2616% %
2617% %
2618%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2619%
2620% OpenBlob() opens a file associated with the image. A file name of '-' sets
2621% the file to stdin for type 'r' and stdout for type 'w'. If the filename
2622% suffix is '.gz', the image is decompressed for type 'r' and compressed
2623% for type 'w'. If the filename prefix is '|', it is piped to or from a
2624% system command.
2625%
2626% The format of the OpenBlob method is:
2627%
2628% MagickBooleanType OpenBlob(const ImageInfo *image_info,Image *image,
2629% const BlobMode mode,ExceptionInfo *exception)
2630%
2631% A description of each parameter follows:
2632%
2633% o image_info: the image info.
2634%
2635% o image: the image.
2636%
2637% o mode: the mode for opening the file.
2638%
2639*/
2640
2641static inline MagickBooleanType SetStreamBuffering(const ImageInfo *image_info,
2642 Image *image)
2643{
2644 const char
2645 *option;
2646
2647 int
2648 status;
2649
2650 size_t
2651 size;
2652
2653 size=MagickMinBufferExtent;
2654 option=GetImageOption(image_info,"stream:buffer-size");
2655 if (option != (const char *) NULL)
2656 size=StringToUnsignedLong(option);
2657 status=setvbuf(image->blob->file_info.file,(char *) NULL,size == 0 ?
2658 _IONBF : _IOFBF,size);
2659 return(status == 0 ? MagickTrue : MagickFalse);
2660}
2661
2662#if defined(MAGICKCORE_ZLIB_DELEGATE)
2663static inline gzFile gzopen_utf8(const char *path,const char *mode)
2664{
2665#if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
2666 return(gzopen(path,mode));
2667#else
2668 gzFile
2669 file;
2670
2671 wchar_t
2672 *path_wide;
2673
2674 path_wide=NTCreateWidePath(path);
2675 if (path_wide == (wchar_t *) NULL)
2676 return((gzFile) NULL);
2677 file=gzopen_w(path_wide,mode);
2678 path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
2679 return(file);
2680#endif
2681}
2682#endif
2683
2684MagickExport MagickBooleanType OpenBlob(const ImageInfo *image_info,
2685 Image *image,const BlobMode mode,ExceptionInfo *exception)
2686{
2687 BlobInfo
2688 *magick_restrict blob_info;
2689
2690 char
2691 extension[MagickPathExtent],
2692 filename[MagickPathExtent];
2693
2694 const char
2695 *type;
2696
2697 int
2698 flags = O_RDONLY;
2699
2700 MagickBooleanType
2701 status;
2702
2703 PolicyRights
2704 rights;
2705
2706 assert(image_info != (ImageInfo *) NULL);
2707 assert(image_info->signature == MagickCoreSignature);
2708 assert(image != (Image *) NULL);
2709 assert(image->signature == MagickCoreSignature);
2710 if (IsEventLogging() != MagickFalse)
2711 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
2712 image_info->filename);
2713 blob_info=image->blob;
2714 if (image_info->blob != (void *) NULL)
2715 {
2716 if (image_info->stream != (StreamHandler) NULL)
2717 blob_info->stream=(StreamHandler) image_info->stream;
2718 AttachBlob(blob_info,image_info->blob,image_info->length);
2719 return(MagickTrue);
2720 }
2721 (void) DetachBlob(blob_info);
2722 blob_info->mode=mode;
2723 switch (mode)
2724 {
2725 case ReadBlobMode:
2726 {
2727 flags=O_RDONLY;
2728 type="r";
2729 break;
2730 }
2731 case ReadBinaryBlobMode:
2732 {
2733 flags=O_RDONLY | O_BINARY;
2734 type="rb";
2735 break;
2736 }
2737 case WriteBlobMode:
2738 {
2739 flags=O_WRONLY | O_CREAT | O_TRUNC;
2740 type="w";
2741 break;
2742 }
2743 case WriteBinaryBlobMode:
2744 {
2745 flags=O_RDWR | O_CREAT | O_TRUNC | O_BINARY;
2746 type="w+b";
2747 break;
2748 }
2749 case AppendBlobMode:
2750 {
2751 flags=O_WRONLY | O_CREAT | O_APPEND;
2752 type="a";
2753 break;
2754 }
2755 case AppendBinaryBlobMode:
2756 {
2757 flags=O_RDWR | O_CREAT | O_APPEND | O_BINARY;
2758 type="a+b";
2759 break;
2760 }
2761 default:
2762 {
2763 flags=O_RDONLY;
2764 type="r";
2765 break;
2766 }
2767 }
2768 if (*type != 'r')
2769 blob_info->synchronize=image_info->synchronize;
2770 if (image_info->stream != (StreamHandler) NULL)
2771 {
2772 blob_info->stream=(StreamHandler) image_info->stream;
2773 if (*type == 'w')
2774 {
2775 blob_info->type=FifoStream;
2776 return(MagickTrue);
2777 }
2778 }
2779 /*
2780 Open image file.
2781 */
2782 *filename='\0';
2783 (void) CopyMagickString(filename,image->filename,MagickPathExtent);
2784 rights=ReadPolicyRights;
2785 if (*type == 'w')
2786 rights=WritePolicyRights;
2787 if (IsPathAuthorized(rights,filename) == MagickFalse)
2788 {
2789 errno=EPERM;
2790 (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
2791 "NotAuthorized","`%s'",filename);
2792 return(MagickFalse);
2793 }
2794 if ((LocaleCompare(filename,"-") == 0) ||
2795 ((*filename == '\0') && (image_info->file == (FILE *) NULL)))
2796 {
2797 blob_info->file_info.file=(*type == 'r') ? stdin : stdout;
2798#if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__OS2__)
2799 if (strchr(type,'b') != (char *) NULL)
2800 (void) setmode(fileno(blob_info->file_info.file),_O_BINARY);
2801#endif
2802 blob_info->type=StandardStream;
2803 blob_info->exempt=MagickTrue;
2804 return(SetStreamBuffering(image_info,image));
2805 }
2806 if ((LocaleNCompare(filename,"fd:",3) == 0) &&
2807 (IsGeometry(filename+3) != MagickFalse))
2808 {
2809 char
2810 fileMode[MagickPathExtent];
2811
2812 *fileMode=(*type);
2813 fileMode[1]='\0';
2814 blob_info->file_info.file=fdopen(StringToLong(filename+3),fileMode);
2815 if (blob_info->file_info.file == (FILE *) NULL)
2816 {
2817 ThrowFileException(exception,BlobError,"UnableToOpenBlob",filename);
2818 return(MagickFalse);
2819 }
2820#if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__OS2__)
2821 if (strchr(type,'b') != (char *) NULL)
2822 (void) setmode(fileno(blob_info->file_info.file),_O_BINARY);
2823#endif
2824 blob_info->type=FileStream;
2825 blob_info->exempt=MagickTrue;
2826 return(SetStreamBuffering(image_info,image));
2827 }
2828#if defined(MAGICKCORE_HAVE_POPEN) && defined(MAGICKCORE_PIPES_SUPPORT)
2829 if (*filename == '|')
2830 {
2831 char
2832 fileMode[MagickPathExtent],
2833 *sanitize_command;
2834
2835 /*
2836 Pipe image to or from a system command.
2837 */
2838#if defined(SIGPIPE)
2839 if (*type == 'w')
2840 (void) signal(SIGPIPE,SIG_IGN);
2841#endif
2842 *fileMode=(*type);
2843 fileMode[1]='\0';
2844 sanitize_command=SanitizeString(filename+1);
2845 blob_info->file_info.file=(FILE *) popen_utf8(sanitize_command,
2846 fileMode);
2847 sanitize_command=DestroyString(sanitize_command);
2848 if (blob_info->file_info.file == (FILE *) NULL)
2849 {
2850 ThrowFileException(exception,BlobError,"UnableToOpenBlob",filename);
2851 return(MagickFalse);
2852 }
2853 blob_info->type=PipeStream;
2854 blob_info->exempt=MagickTrue;
2855 return(SetStreamBuffering(image_info,image));
2856 }
2857#endif
2858 status=GetPathAttributes(filename,&blob_info->properties);
2859#if defined(S_ISFIFO)
2860 if ((status != MagickFalse) && S_ISFIFO(blob_info->properties.st_mode))
2861 {
2862 blob_info->file_info.file=(FILE *) fopen_utf8(filename,type);
2863 if (blob_info->file_info.file == (FILE *) NULL)
2864 {
2865 ThrowFileException(exception,BlobError,"UnableToOpenBlob",filename);
2866 return(MagickFalse);
2867 }
2868 blob_info->type=FileStream;
2869 blob_info->exempt=MagickTrue;
2870 return(SetStreamBuffering(image_info,image));
2871 }
2872#endif
2873 GetPathComponent(image->filename,ExtensionPath,extension);
2874 if (*type == 'w')
2875 {
2876 (void) CopyMagickString(filename,image->filename,MagickPathExtent);
2877 if ((image_info->adjoin == MagickFalse) ||
2878 (strchr(filename,'%') != (char *) NULL))
2879 {
2880 /*
2881 Form filename for multi-part images.
2882 */
2883 (void) InterpretImageFilename(image_info,image,image->filename,(int)
2884 image->scene,filename);
2885 if ((LocaleCompare(filename,image->filename) == 0) &&
2886 ((GetPreviousImageInList(image) != (Image *) NULL) ||
2887 (GetNextImageInList(image) != (Image *) NULL)))
2888 {
2889 char
2890 path[MagickPathExtent];
2891
2892 GetPathComponent(image->filename,RootPath,path);
2893 if (*extension == '\0')
2894 (void) FormatLocaleString(filename,MagickPathExtent,"%s-%.20g",
2895 path,(double) image->scene);
2896 else
2897 (void) FormatLocaleString(filename,MagickPathExtent,
2898 "%s-%.20g.%s",path,(double) image->scene,extension);
2899 }
2900 (void) CopyMagickString(image->filename,filename,MagickPathExtent);
2901#if defined(macintosh)
2902 SetApplicationType(filename,image_info->magick,'8BIM');
2903#endif
2904 }
2905 }
2906 if (image_info->file != (FILE *) NULL)
2907 {
2908 blob_info->file_info.file=image_info->file;
2909 blob_info->type=FileStream;
2910 blob_info->exempt=MagickTrue;
2911 }
2912 else
2913 if (*type == 'r')
2914 {
2915 int
2916 file;
2917
2918 blob_info->file_info.file=(FILE *) NULL;
2919 file=open_utf8(filename,flags,0);
2920 if (file >= 0)
2921 blob_info->file_info.file=fdopen(file,type);
2922 if (blob_info->file_info.file != (FILE *) NULL)
2923 {
2924 size_t
2925 count;
2926
2927 unsigned char
2928 magick[3];
2929
2930 blob_info->type=FileStream;
2931 (void) fstat(fileno(blob_info->file_info.file),
2932 &blob_info->properties);
2933 (void) SetStreamBuffering(image_info,image);
2934 (void) memset(magick,0,sizeof(magick));
2935 count=fread(magick,1,sizeof(magick),blob_info->file_info.file);
2936 (void) fseek(blob_info->file_info.file,-((off_t) count),SEEK_CUR);
2937#if defined(MAGICKCORE_POSIX_SUPPORT)
2938 (void) fflush(blob_info->file_info.file);
2939#endif
2940 (void) LogMagickEvent(BlobEvent,GetMagickModule(),
2941 " read %.20g magic header bytes",(double) count);
2942#if defined(MAGICKCORE_ZLIB_DELEGATE)
2943 if (((int) magick[0] == 0x1F) && ((int) magick[1] == 0x8B) &&
2944 ((int) magick[2] == 0x08))
2945 {
2946 gzFile
2947 gzfile = gzopen_utf8(filename,"rb");
2948
2949 if (gzfile != (gzFile) NULL)
2950 {
2951 if (blob_info->file_info.file != (FILE *) NULL)
2952 (void) fclose(blob_info->file_info.file);
2953 blob_info->file_info.file=(FILE *) NULL;
2954 blob_info->file_info.gzfile=gzfile;
2955 blob_info->type=ZipStream;
2956 }
2957 }
2958#endif
2959#if defined(MAGICKCORE_BZLIB_DELEGATE)
2960 if (strncmp((char *) magick,"BZh",3) == 0)
2961 {
2962 BZFILE
2963 *bzfile = BZ2_bzopen(filename,"r");
2964
2965 if (bzfile != (BZFILE *) NULL)
2966 {
2967 if (blob_info->file_info.file != (FILE *) NULL)
2968 (void) fclose(blob_info->file_info.file);
2969 blob_info->file_info.file=(FILE *) NULL;
2970 blob_info->file_info.bzfile=bzfile;
2971 blob_info->type=BZipStream;
2972 }
2973 }
2974#endif
2975 if (blob_info->type == FileStream)
2976 {
2977 const MagickInfo
2978 *magick_info;
2979
2980 ExceptionInfo
2981 *sans_exception;
2982
2983 size_t
2984 length;
2985
2986 sans_exception=AcquireExceptionInfo();
2987 magick_info=GetMagickInfo(image_info->magick,sans_exception);
2988 sans_exception=DestroyExceptionInfo(sans_exception);
2989 length=(size_t) blob_info->properties.st_size;
2990 if ((magick_info != (const MagickInfo *) NULL) &&
2991 (GetMagickBlobSupport(magick_info) != MagickFalse) &&
2992 (length > MagickMaxBufferExtent) &&
2993 (AcquireMagickResource(MapResource,length) != MagickFalse))
2994 {
2995 void
2996 *blob;
2997
2998 blob=MapBlob(fileno(blob_info->file_info.file),ReadMode,0,
2999 length);
3000 if (blob == (void *) NULL)
3001 RelinquishMagickResource(MapResource,length);
3002 else
3003 {
3004 /*
3005 Format supports blobs-- use memory-mapped I/O.
3006 */
3007 if (image_info->file != (FILE *) NULL)
3008 blob_info->exempt=MagickFalse;
3009 else
3010 {
3011 (void) fclose(blob_info->file_info.file);
3012 blob_info->file_info.file=(FILE *) NULL;
3013 }
3014 AttachBlob(blob_info,blob,length);
3015 blob_info->mapped=MagickTrue;
3016 }
3017 }
3018 }
3019 }
3020 }
3021 else
3022#if defined(MAGICKCORE_ZLIB_DELEGATE)
3023 if ((LocaleCompare(extension,"gz") == 0) ||
3024 (LocaleCompare(extension,"wmz") == 0) ||
3025 (LocaleCompare(extension,"svgz") == 0))
3026 {
3027 blob_info->file_info.gzfile=gzopen_utf8(filename,"wb");
3028 if (blob_info->file_info.gzfile != (gzFile) NULL)
3029 blob_info->type=ZipStream;
3030 }
3031 else
3032#endif
3033#if defined(MAGICKCORE_BZLIB_DELEGATE)
3034 if (LocaleCompare(extension,"bz2") == 0)
3035 {
3036 if (mode == WriteBinaryBlobMode)
3037 type="w";
3038 blob_info->file_info.bzfile=BZ2_bzopen(filename,"w");
3039 if (blob_info->file_info.bzfile != (BZFILE *) NULL)
3040 blob_info->type=BZipStream;
3041 }
3042 else
3043#endif
3044 {
3045 int
3046 file;
3047
3048 blob_info->file_info.file=(FILE *) NULL;
3049 file=open_utf8(filename,flags,P_MODE);
3050 if (file >= 0)
3051 blob_info->file_info.file=fdopen(file,type);
3052 if (blob_info->file_info.file != (FILE *) NULL)
3053 {
3054 blob_info->type=FileStream;
3055 (void) SetStreamBuffering(image_info,image);
3056 }
3057 }
3058 if (IsPathAuthorized(rights,filename) == MagickFalse)
3059 {
3060 errno=EPERM;
3061 (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
3062 "NotAuthorized","`%s'",filename);
3063 return(MagickFalse);
3064 }
3065 blob_info->status=0;
3066 blob_info->error_number=0;
3067 if (blob_info->type != UndefinedStream)
3068 blob_info->size=GetBlobSize(image);
3069 else
3070 {
3071 ThrowFileException(exception,BlobError,"UnableToOpenBlob",filename);
3072 return(MagickFalse);
3073 }
3074 return(MagickTrue);
3075}
3076␌
3077/*
3078%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3079% %
3080% %
3081% %
3082+ P i n g B l o b %
3083% %
3084% %
3085% %
3086%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3087%
3088% PingBlob() returns all the attributes of an image or image sequence except
3089% for the pixels. It is much faster and consumes far less memory than
3090% BlobToImage(). On failure, a NULL image is returned and exception
3091% describes the reason for the failure.
3092%
3093% The format of the PingBlob method is:
3094%
3095% Image *PingBlob(const ImageInfo *image_info,const void *blob,
3096% const size_t length,ExceptionInfo *exception)
3097%
3098% A description of each parameter follows:
3099%
3100% o image_info: the image info.
3101%
3102% o blob: the address of a character stream in one of the image formats
3103% understood by ImageMagick.
3104%
3105% o length: This size_t integer reflects the length in bytes of the blob.
3106%
3107% o exception: return any errors or warnings in this structure.
3108%
3109*/
3110
3111#if defined(__cplusplus) || defined(c_plusplus)
3112extern "C" {
3113#endif
3114
3115static size_t PingStream(const Image *magick_unused(image),
3116 const void *magick_unused(pixels),const size_t columns)
3117{
3118 magick_unreferenced(image);
3119 magick_unreferenced(pixels);
3120
3121 return(columns);
3122}
3123
3124#if defined(__cplusplus) || defined(c_plusplus)
3125}
3126#endif
3127
3128MagickExport Image *PingBlob(const ImageInfo *image_info,const void *blob,
3129 const size_t length,ExceptionInfo *exception)
3130{
3131 const MagickInfo
3132 *magick_info;
3133
3134 Image
3135 *image;
3136
3137 ImageInfo
3138 *clone_info,
3139 *ping_info;
3140
3141 MagickBooleanType
3142 status;
3143
3144 assert(image_info != (ImageInfo *) NULL);
3145 assert(image_info->signature == MagickCoreSignature);
3146 assert(exception != (ExceptionInfo *) NULL);
3147 if (IsEventLogging() != MagickFalse)
3148 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
3149 image_info->filename);
3150 if ((blob == (const void *) NULL) || (length == 0))
3151 {
3152 (void) ThrowMagickException(exception,GetMagickModule(),BlobError,
3153 "ZeroLengthBlobNotPermitted","`%s'",image_info->filename);
3154 return((Image *) NULL);
3155 }
3156 ping_info=CloneImageInfo(image_info);
3157 ping_info->blob=(void *) blob;
3158 ping_info->length=length;
3159 ping_info->ping=MagickTrue;
3160 if (*ping_info->magick == '\0')
3161 (void) SetImageInfo(ping_info,0,exception);
3162 magick_info=GetMagickInfo(ping_info->magick,exception);
3163 if (magick_info == (const MagickInfo *) NULL)
3164 {
3165 (void) ThrowMagickException(exception,GetMagickModule(),
3166 MissingDelegateError,"NoDecodeDelegateForThisImageFormat","`%s'",
3167 ping_info->magick);
3168 ping_info=DestroyImageInfo(ping_info);
3169 return((Image *) NULL);
3170 }
3171 if (GetMagickBlobSupport(magick_info) != MagickFalse)
3172 {
3173 char
3174 filename[MagickPathExtent];
3175
3176 /*
3177 Native blob support for this image format.
3178 */
3179 (void) CopyMagickString(filename,ping_info->filename,MagickPathExtent);
3180 (void) FormatLocaleString(ping_info->filename,MagickPathExtent,"%s:%s",
3181 ping_info->magick,filename);
3182 image=ReadStream(ping_info,&PingStream,exception);
3183 if (image != (Image *) NULL)
3184 (void) DetachBlob(image->blob);
3185 ping_info=DestroyImageInfo(ping_info);
3186 return(image);
3187 }
3188 /*
3189 Write blob to a temporary file on disk.
3190 */
3191 ping_info->blob=(void *) NULL;
3192 ping_info->length=0;
3193 *ping_info->filename='\0';
3194 status=BlobToFile(ping_info->filename,blob,length,exception);
3195 if (status == MagickFalse)
3196 {
3197 (void) RelinquishUniqueFileResource(ping_info->filename);
3198 ping_info=DestroyImageInfo(ping_info);
3199 return((Image *) NULL);
3200 }
3201 clone_info=CloneImageInfo(ping_info);
3202 (void) FormatLocaleString(clone_info->filename,MagickPathExtent,"%s:%s",
3203 ping_info->magick,ping_info->filename);
3204 image=ReadStream(clone_info,&PingStream,exception);
3205 if (image != (Image *) NULL)
3206 {
3207 Image
3208 *images;
3209
3210 /*
3211 Restore original filenames and image format.
3212 */
3213 for (images=GetFirstImageInList(image); images != (Image *) NULL; )
3214 {
3215 (void) CopyMagickString(images->filename,image_info->filename,
3216 MagickPathExtent);
3217 (void) CopyMagickString(images->magick_filename,image_info->filename,
3218 MagickPathExtent);
3219 (void) CopyMagickString(images->magick,magick_info->name,
3220 MagickPathExtent);
3221 images=GetNextImageInList(images);
3222 }
3223 }
3224 clone_info=DestroyImageInfo(clone_info);
3225 (void) RelinquishUniqueFileResource(ping_info->filename);
3226 ping_info=DestroyImageInfo(ping_info);
3227 return(image);
3228}
3229␌
3230/*
3231%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3232% %
3233% %
3234% %
3235+ R e a d B l o b %
3236% %
3237% %
3238% %
3239%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3240%
3241% ReadBlob() reads data from the blob or image file and returns it. It
3242% returns the number of bytes read. If length is zero, ReadBlob() returns
3243% zero and has no other results. If length is greater than MAGICK_SSIZE_MAX, the
3244% result is unspecified.
3245%
3246% The format of the ReadBlob method is:
3247%
3248% ssize_t ReadBlob(Image *image,const size_t length,unsigned char *data)
3249%
3250% A description of each parameter follows:
3251%
3252% o image: the image.
3253%
3254% o length: Specifies an integer representing the number of bytes to read
3255% from the file.
3256%
3257% o data: Specifies an area to place the information requested from the
3258% file.
3259%
3260*/
3261MagickExport ssize_t ReadBlob(Image *image,const size_t length,
3262 unsigned char *data)
3263{
3264 BlobInfo
3265 *magick_restrict blob_info;
3266
3267 int
3268 c;
3269
3270 unsigned char
3271 *q;
3272
3273 ssize_t
3274 count;
3275
3276 assert(image != (Image *) NULL);
3277 assert(image->signature == MagickCoreSignature);
3278 assert(image->blob != (BlobInfo *) NULL);
3279 assert(image->blob->type != UndefinedStream);
3280 if (length == 0)
3281 return(0);
3282 assert(data != (void *) NULL);
3283 blob_info=image->blob;
3284 count=0;
3285 q=data;
3286 switch (blob_info->type)
3287 {
3288 case UndefinedStream:
3289 break;
3290 case StandardStream:
3291 case FileStream:
3292 case PipeStream:
3293 {
3294 switch (length)
3295 {
3296 default:
3297 {
3298 count=(ssize_t) fread(q,1,length,blob_info->file_info.file);
3299 break;
3300 }
3301 case 4:
3302 {
3303 c=getc(blob_info->file_info.file);
3304 if (c == EOF)
3305 break;
3306 *q++=(unsigned char) c;
3307 count++;
3308 magick_fallthrough;
3309 }
3310 case 3:
3311 {
3312 c=getc(blob_info->file_info.file);
3313 if (c == EOF)
3314 break;
3315 *q++=(unsigned char) c;
3316 count++;
3317 magick_fallthrough;
3318 }
3319 case 2:
3320 {
3321 c=getc(blob_info->file_info.file);
3322 if (c == EOF)
3323 break;
3324 *q++=(unsigned char) c;
3325 count++;
3326 magick_fallthrough;
3327 }
3328 case 1:
3329 {
3330 c=getc(blob_info->file_info.file);
3331 if (c == EOF)
3332 break;
3333 *q++=(unsigned char) c;
3334 count++;
3335 magick_fallthrough;
3336 }
3337 case 0:
3338 break;
3339 }
3340 if ((count != (ssize_t) length) &&
3341 (ferror(blob_info->file_info.file) != 0))
3342 ThrowBlobException(blob_info);
3343 break;
3344 }
3345 case ZipStream:
3346 {
3347#if defined(MAGICKCORE_ZLIB_DELEGATE)
3348 int
3349 status;
3350
3351 switch (length)
3352 {
3353 default:
3354 {
3355 ssize_t
3356 i;
3357
3358 for (i=0; i < (ssize_t) length; i+=count)
3359 {
3360 count=(ssize_t) gzread(blob_info->file_info.gzfile,q+i,
3361 (unsigned int) MagickMin(length-i,MagickMaxBufferExtent));
3362 if (count <= 0)
3363 {
3364 count=0;
3365 if (errno != EINTR)
3366 break;
3367 }
3368 }
3369 count=i;
3370 break;
3371 }
3372 case 4:
3373 {
3374 c=gzgetc(blob_info->file_info.gzfile);
3375 if (c == EOF)
3376 break;
3377 *q++=(unsigned char) c;
3378 count++;
3379 magick_fallthrough;
3380 }
3381 case 3:
3382 {
3383 c=gzgetc(blob_info->file_info.gzfile);
3384 if (c == EOF)
3385 break;
3386 *q++=(unsigned char) c;
3387 count++;
3388 magick_fallthrough;
3389 }
3390 case 2:
3391 {
3392 c=gzgetc(blob_info->file_info.gzfile);
3393 if (c == EOF)
3394 break;
3395 *q++=(unsigned char) c;
3396 count++;
3397 magick_fallthrough;
3398 }
3399 case 1:
3400 {
3401 c=gzgetc(blob_info->file_info.gzfile);
3402 if (c == EOF)
3403 break;
3404 *q++=(unsigned char) c;
3405 count++;
3406 magick_fallthrough;
3407 }
3408 case 0:
3409 break;
3410 }
3411 status=Z_OK;
3412 (void) gzerror(blob_info->file_info.gzfile,&status);
3413 if ((count != (ssize_t) length) && (status != Z_OK))
3414 ThrowBlobException(blob_info);
3415 if (blob_info->eof == MagickFalse)
3416 blob_info->eof=gzeof(blob_info->file_info.gzfile) != 0 ? MagickTrue :
3417 MagickFalse;
3418#endif
3419 break;
3420 }
3421 case BZipStream:
3422 {
3423#if defined(MAGICKCORE_BZLIB_DELEGATE)
3424 int
3425 status;
3426
3427 ssize_t
3428 i;
3429
3430 for (i=0; i < (ssize_t) length; i+=count)
3431 {
3432 count=(ssize_t) BZ2_bzread(blob_info->file_info.bzfile,q+i,
3433 (unsigned int) MagickMin(length-i,MagickMaxBufferExtent));
3434 if (count <= 0)
3435 {
3436 count=0;
3437 if (errno != EINTR)
3438 break;
3439 }
3440 }
3441 count=i;
3442 status=BZ_OK;
3443 (void) BZ2_bzerror(blob_info->file_info.bzfile,&status);
3444 if ((count != (ssize_t) length) && (status != BZ_OK))
3445 ThrowBlobException(blob_info);
3446#endif
3447 break;
3448 }
3449 case FifoStream:
3450 break;
3451 case BlobStream:
3452 {
3453 const unsigned char
3454 *p;
3455
3456 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
3457 {
3458 blob_info->eof=MagickTrue;
3459 break;
3460 }
3461 p=blob_info->data+blob_info->offset;
3462 count=(ssize_t) MagickMin((MagickOffsetType) length,(MagickOffsetType)
3463 blob_info->length-blob_info->offset);
3464 blob_info->offset+=count;
3465 if (count != (ssize_t) length)
3466 blob_info->eof=MagickTrue;
3467 (void) memcpy(q,p,(size_t) count);
3468 break;
3469 }
3470 }
3471 return(count);
3472}
3473␌
3474/*
3475%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3476% %
3477% %
3478% %
3479+ R e a d B l o b B y t e %
3480% %
3481% %
3482% %
3483%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3484%
3485% ReadBlobByte() reads a single byte from the image file and returns it.
3486%
3487% The format of the ReadBlobByte method is:
3488%
3489% int ReadBlobByte(Image *image)
3490%
3491% A description of each parameter follows.
3492%
3493% o image: the image.
3494%
3495*/
3496MagickExport int ReadBlobByte(Image *image)
3497{
3498 BlobInfo
3499 *magick_restrict blob_info;
3500
3501 int
3502 c;
3503
3504 assert(image != (Image *) NULL);
3505 assert(image->signature == MagickCoreSignature);
3506 assert(image->blob != (BlobInfo *) NULL);
3507 assert(image->blob->type != UndefinedStream);
3508 blob_info=image->blob;
3509 switch (blob_info->type)
3510 {
3511 case StandardStream:
3512 case FileStream:
3513 case PipeStream:
3514 {
3515 c=getc(blob_info->file_info.file);
3516 if (c == EOF)
3517 {
3518 if (ferror(blob_info->file_info.file) != 0)
3519 ThrowBlobException(blob_info);
3520 return(EOF);
3521 }
3522 break;
3523 }
3524 case BlobStream:
3525 {
3526 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
3527 {
3528 blob_info->eof=MagickTrue;
3529 return(EOF);
3530 }
3531 c=(int) (*((unsigned char *) blob_info->data+blob_info->offset));
3532 blob_info->offset++;
3533 break;
3534 }
3535 default:
3536 {
3537 ssize_t
3538 count;
3539
3540 unsigned char
3541 buffer[1];
3542
3543 count=ReadBlob(image,1,buffer);
3544 if (count != 1)
3545 return(EOF);
3546 c=(int) *buffer;
3547 break;
3548 }
3549 }
3550 return(c);
3551}
3552␌
3553/*
3554%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3555% %
3556% %
3557% %
3558+ R e a d B l o b D o u b l e %
3559% %
3560% %
3561% %
3562%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3563%
3564% ReadBlobDouble() reads a double value as a 64-bit quantity in the byte-order
3565% specified by the endian member of the image structure.
3566%
3567% The format of the ReadBlobDouble method is:
3568%
3569% double ReadBlobDouble(Image *image)
3570%
3571% A description of each parameter follows.
3572%
3573% o image: the image.
3574%
3575*/
3576MagickExport double ReadBlobDouble(Image *image)
3577{
3578 union
3579 {
3580 MagickSizeType
3581 unsigned_value;
3582
3583 double
3584 double_value;
3585 } quantum;
3586
3587 quantum.double_value=0.0;
3588 quantum.unsigned_value=ReadBlobLongLong(image);
3589 return(quantum.double_value);
3590}
3591␌
3592/*
3593%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3594% %
3595% %
3596% %
3597+ R e a d B l o b F l o a t %
3598% %
3599% %
3600% %
3601%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3602%
3603% ReadBlobFloat() reads a float value as a 32-bit quantity in the byte-order
3604% specified by the endian member of the image structure.
3605%
3606% The format of the ReadBlobFloat method is:
3607%
3608% float ReadBlobFloat(Image *image)
3609%
3610% A description of each parameter follows.
3611%
3612% o image: the image.
3613%
3614*/
3615MagickExport float ReadBlobFloat(Image *image)
3616{
3617 union
3618 {
3619 unsigned int
3620 unsigned_value;
3621
3622 float
3623 float_value;
3624 } quantum;
3625
3626 quantum.float_value=0.0;
3627 quantum.unsigned_value=ReadBlobLong(image);
3628 return(quantum.float_value);
3629}
3630␌
3631/*
3632%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3633% %
3634% %
3635% %
3636+ R e a d B l o b L o n g %
3637% %
3638% %
3639% %
3640%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3641%
3642% ReadBlobLong() reads a unsigned int value as a 32-bit quantity in the
3643% byte-order specified by the endian member of the image structure.
3644%
3645% The format of the ReadBlobLong method is:
3646%
3647% unsigned int ReadBlobLong(Image *image)
3648%
3649% A description of each parameter follows.
3650%
3651% o image: the image.
3652%
3653*/
3654MagickExport unsigned int ReadBlobLong(Image *image)
3655{
3656 const unsigned char
3657 *p;
3658
3659 ssize_t
3660 count;
3661
3662 unsigned char
3663 buffer[4];
3664
3665 unsigned int
3666 value;
3667
3668 assert(image != (Image *) NULL);
3669 assert(image->signature == MagickCoreSignature);
3670 *buffer='\0';
3671 p=(const unsigned char *) ReadBlobStream(image,4,buffer,&count);
3672 if (count != 4)
3673 return(0UL);
3674 if (image->endian == LSBEndian)
3675 {
3676 value=(unsigned int) (*p++);
3677 value|=(unsigned int) (*p++) << 8;
3678 value|=(unsigned int) (*p++) << 16;
3679 value|=(unsigned int) (*p++) << 24;
3680 return(value);
3681 }
3682 value=(unsigned int) (*p++) << 24;
3683 value|=(unsigned int) (*p++) << 16;
3684 value|=(unsigned int) (*p++) << 8;
3685 value|=(unsigned int) (*p++);
3686 return(value);
3687}
3688␌
3689/*
3690%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3691% %
3692% %
3693% %
3694+ R e a d B l o b L o n g L o n g %
3695% %
3696% %
3697% %
3698%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3699%
3700% ReadBlobLongLong() reads a long long value as a 64-bit quantity in the
3701% byte-order specified by the endian member of the image structure.
3702%
3703% The format of the ReadBlobLongLong method is:
3704%
3705% MagickSizeType ReadBlobLongLong(Image *image)
3706%
3707% A description of each parameter follows.
3708%
3709% o image: the image.
3710%
3711*/
3712MagickExport MagickSizeType ReadBlobLongLong(Image *image)
3713{
3714 MagickSizeType
3715 value;
3716
3717 const unsigned char
3718 *p;
3719
3720 ssize_t
3721 count;
3722
3723 unsigned char
3724 buffer[8];
3725
3726 assert(image != (Image *) NULL);
3727 assert(image->signature == MagickCoreSignature);
3728 *buffer='\0';
3729 p=(const unsigned char *) ReadBlobStream(image,8,buffer,&count);
3730 if (count != 8)
3731 return(MagickULLConstant(0));
3732 if (image->endian == LSBEndian)
3733 {
3734 value=(MagickSizeType) (*p++);
3735 value|=(MagickSizeType) (*p++) << 8;
3736 value|=(MagickSizeType) (*p++) << 16;
3737 value|=(MagickSizeType) (*p++) << 24;
3738 value|=(MagickSizeType) (*p++) << 32;
3739 value|=(MagickSizeType) (*p++) << 40;
3740 value|=(MagickSizeType) (*p++) << 48;
3741 value|=(MagickSizeType) (*p++) << 56;
3742 return(value);
3743 }
3744 value=(MagickSizeType) (*p++) << 56;
3745 value|=(MagickSizeType) (*p++) << 48;
3746 value|=(MagickSizeType) (*p++) << 40;
3747 value|=(MagickSizeType) (*p++) << 32;
3748 value|=(MagickSizeType) (*p++) << 24;
3749 value|=(MagickSizeType) (*p++) << 16;
3750 value|=(MagickSizeType) (*p++) << 8;
3751 value|=(MagickSizeType) (*p++);
3752 return(value);
3753}
3754␌
3755/*
3756%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3757% %
3758% %
3759% %
3760+ R e a d B l o b S h o r t %
3761% %
3762% %
3763% %
3764%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3765%
3766% ReadBlobShort() reads a short value as a 16-bit quantity in the byte-order
3767% specified by the endian member of the image structure.
3768%
3769% The format of the ReadBlobShort method is:
3770%
3771% unsigned short ReadBlobShort(Image *image)
3772%
3773% A description of each parameter follows.
3774%
3775% o image: the image.
3776%
3777*/
3778MagickExport unsigned short ReadBlobShort(Image *image)
3779{
3780 const unsigned char
3781 *p;
3782
3783 unsigned short
3784 value;
3785
3786 ssize_t
3787 count;
3788
3789 unsigned char
3790 buffer[2];
3791
3792 assert(image != (Image *) NULL);
3793 assert(image->signature == MagickCoreSignature);
3794 *buffer='\0';
3795 p=(const unsigned char *) ReadBlobStream(image,2,buffer,&count);
3796 if (count != 2)
3797 return((unsigned short) 0U);
3798 if (image->endian == LSBEndian)
3799 {
3800 value=(unsigned short) (*p++);
3801 value|=(unsigned short) (*p++) << 8;
3802 return(value);
3803 }
3804 value=(unsigned short) ((unsigned short) (*p++) << 8);
3805 value|=(unsigned short) (*p++);
3806 return(value);
3807}
3808␌
3809/*
3810%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3811% %
3812% %
3813% %
3814+ R e a d B l o b L S B L o n g %
3815% %
3816% %
3817% %
3818%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3819%
3820% ReadBlobLSBLong() reads a unsigned int value as a 32-bit quantity in
3821% least-significant byte first order.
3822%
3823% The format of the ReadBlobLSBLong method is:
3824%
3825% unsigned int ReadBlobLSBLong(Image *image)
3826%
3827% A description of each parameter follows.
3828%
3829% o image: the image.
3830%
3831*/
3832MagickExport unsigned int ReadBlobLSBLong(Image *image)
3833{
3834 const unsigned char
3835 *p;
3836
3837 unsigned int
3838 value;
3839
3840 ssize_t
3841 count;
3842
3843 unsigned char
3844 buffer[4];
3845
3846 assert(image != (Image *) NULL);
3847 assert(image->signature == MagickCoreSignature);
3848 *buffer='\0';
3849 p=(const unsigned char *) ReadBlobStream(image,4,buffer,&count);
3850 if (count != 4)
3851 return(0U);
3852 value=(unsigned int) (*p++);
3853 value|=(unsigned int) (*p++) << 8;
3854 value|=(unsigned int) (*p++) << 16;
3855 value|=(unsigned int) (*p++) << 24;
3856 return(value);
3857}
3858␌
3859/*
3860%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3861% %
3862% %
3863% %
3864+ R e a d B l o b L S B S i g n e d L o n g %
3865% %
3866% %
3867% %
3868%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3869%
3870% ReadBlobLSBSignedLong() reads a signed int value as a 32-bit quantity in
3871% least-significant byte first order.
3872%
3873% The format of the ReadBlobLSBSignedLong method is:
3874%
3875% signed int ReadBlobLSBSignedLong(Image *image)
3876%
3877% A description of each parameter follows.
3878%
3879% o image: the image.
3880%
3881*/
3882MagickExport signed int ReadBlobLSBSignedLong(Image *image)
3883{
3884 union
3885 {
3886 unsigned int
3887 unsigned_value;
3888
3889 signed int
3890 signed_value;
3891 } quantum;
3892
3893 quantum.unsigned_value=ReadBlobLSBLong(image);
3894 return(quantum.signed_value);
3895}
3896␌
3897/*
3898%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3899% %
3900% %
3901% %
3902+ R e a d B l o b L S B S h o r t %
3903% %
3904% %
3905% %
3906%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3907%
3908% ReadBlobLSBShort() reads a short value as a 16-bit quantity in
3909% least-significant byte first order.
3910%
3911% The format of the ReadBlobLSBShort method is:
3912%
3913% unsigned short ReadBlobLSBShort(Image *image)
3914%
3915% A description of each parameter follows.
3916%
3917% o image: the image.
3918%
3919*/
3920MagickExport unsigned short ReadBlobLSBShort(Image *image)
3921{
3922 const unsigned char
3923 *p;
3924
3925 unsigned short
3926 value;
3927
3928 ssize_t
3929 count;
3930
3931 unsigned char
3932 buffer[2];
3933
3934 assert(image != (Image *) NULL);
3935 assert(image->signature == MagickCoreSignature);
3936 *buffer='\0';
3937 p=(const unsigned char *) ReadBlobStream(image,2,buffer,&count);
3938 if (count != 2)
3939 return((unsigned short) 0U);
3940 value=(unsigned short) (*p++);
3941 value|=(unsigned short) (*p++) << 8;
3942 return(value);
3943}
3944␌
3945/*
3946%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3947% %
3948% %
3949% %
3950+ R e a d B l o b L S B S i g n e d S h o r t %
3951% %
3952% %
3953% %
3954%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3955%
3956% ReadBlobLSBSignedShort() reads a signed short value as a 16-bit quantity in
3957% least-significant byte-order.
3958%
3959% The format of the ReadBlobLSBSignedShort method is:
3960%
3961% signed short ReadBlobLSBSignedShort(Image *image)
3962%
3963% A description of each parameter follows.
3964%
3965% o image: the image.
3966%
3967*/
3968MagickExport signed short ReadBlobLSBSignedShort(Image *image)
3969{
3970 union
3971 {
3972 unsigned short
3973 unsigned_value;
3974
3975 signed short
3976 signed_value;
3977 } quantum;
3978
3979 quantum.unsigned_value=ReadBlobLSBShort(image);
3980 return(quantum.signed_value);
3981}
3982␌
3983/*
3984%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3985% %
3986% %
3987% %
3988+ R e a d B l o b M S B L o n g %
3989% %
3990% %
3991% %
3992%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3993%
3994% ReadBlobMSBLong() reads a unsigned int value as a 32-bit quantity in
3995% most-significant byte first order.
3996%
3997% The format of the ReadBlobMSBLong method is:
3998%
3999% unsigned int ReadBlobMSBLong(Image *image)
4000%
4001% A description of each parameter follows.
4002%
4003% o image: the image.
4004%
4005*/
4006MagickExport unsigned int ReadBlobMSBLong(Image *image)
4007{
4008 const unsigned char
4009 *p;
4010
4011 unsigned int
4012 value;
4013
4014 ssize_t
4015 count;
4016
4017 unsigned char
4018 buffer[4];
4019
4020 assert(image != (Image *) NULL);
4021 assert(image->signature == MagickCoreSignature);
4022 *buffer='\0';
4023 p=(const unsigned char *) ReadBlobStream(image,4,buffer,&count);
4024 if (count != 4)
4025 return(0UL);
4026 value=(unsigned int) (*p++) << 24;
4027 value|=(unsigned int) (*p++) << 16;
4028 value|=(unsigned int) (*p++) << 8;
4029 value|=(unsigned int) (*p++);
4030 return(value);
4031}
4032␌
4033/*
4034%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4035% %
4036% %
4037% %
4038+ R e a d B l o b M S B L o n g L o n g %
4039% %
4040% %
4041% %
4042%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4043%
4044% ReadBlobMSBLongLong() reads a unsigned long int value as a 64-bit quantity
4045% in most-significant byte first order.
4046%
4047% The format of the ReadBlobMSBLongLong method is:
4048%
4049% unsigned int ReadBlobMSBLongLong(Image *image)
4050%
4051% A description of each parameter follows.
4052%
4053% o image: the image.
4054%
4055*/
4056MagickExport MagickSizeType ReadBlobMSBLongLong(Image *image)
4057{
4058 const unsigned char
4059 *p;
4060
4061 MagickSizeType
4062 value;
4063
4064 ssize_t
4065 count;
4066
4067 unsigned char
4068 buffer[8];
4069
4070 assert(image != (Image *) NULL);
4071 assert(image->signature == MagickCoreSignature);
4072 *buffer='\0';
4073 p=(const unsigned char *) ReadBlobStream(image,8,buffer,&count);
4074 if (count != 8)
4075 return(MagickULLConstant(0));
4076 value=(MagickSizeType) (*p++) << 56;
4077 value|=(MagickSizeType) (*p++) << 48;
4078 value|=(MagickSizeType) (*p++) << 40;
4079 value|=(MagickSizeType) (*p++) << 32;
4080 value|=(MagickSizeType) (*p++) << 24;
4081 value|=(MagickSizeType) (*p++) << 16;
4082 value|=(MagickSizeType) (*p++) << 8;
4083 value|=(MagickSizeType) (*p++);
4084 return(value);
4085}
4086␌
4087/*
4088%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4089% %
4090% %
4091% %
4092+ R e a d B l o b M S B S h o r t %
4093% %
4094% %
4095% %
4096%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4097%
4098% ReadBlobMSBShort() reads a short value as a 16-bit quantity in
4099% most-significant byte first order.
4100%
4101% The format of the ReadBlobMSBShort method is:
4102%
4103% unsigned short ReadBlobMSBShort(Image *image)
4104%
4105% A description of each parameter follows.
4106%
4107% o image: the image.
4108%
4109*/
4110MagickExport unsigned short ReadBlobMSBShort(Image *image)
4111{
4112 const unsigned char
4113 *p;
4114
4115 unsigned short
4116 value;
4117
4118 ssize_t
4119 count;
4120
4121 unsigned char
4122 buffer[2];
4123
4124 assert(image != (Image *) NULL);
4125 assert(image->signature == MagickCoreSignature);
4126 *buffer='\0';
4127 p=(const unsigned char *) ReadBlobStream(image,2,buffer,&count);
4128 if (count != 2)
4129 return((unsigned short) 0U);
4130 value=(unsigned short) ((*p++) << 8);
4131 value|=(unsigned short) (*p++);
4132 return(value);
4133}
4134␌
4135/*
4136%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4137% %
4138% %
4139% %
4140+ R e a d B l o b M S B S i g n e d L o n g %
4141% %
4142% %
4143% %
4144%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4145%
4146% ReadBlobMSBSignedLong() reads a signed int value as a 32-bit quantity in
4147% most-significant byte-order.
4148%
4149% The format of the ReadBlobMSBSignedLong method is:
4150%
4151% signed int ReadBlobMSBSignedLong(Image *image)
4152%
4153% A description of each parameter follows.
4154%
4155% o image: the image.
4156%
4157*/
4158MagickExport signed int ReadBlobMSBSignedLong(Image *image)
4159{
4160 union
4161 {
4162 unsigned int
4163 unsigned_value;
4164
4165 signed int
4166 signed_value;
4167 } quantum;
4168
4169 quantum.unsigned_value=ReadBlobMSBLong(image);
4170 return(quantum.signed_value);
4171}
4172␌
4173/*
4174%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4175% %
4176% %
4177% %
4178+ R e a d B l o b M S B S i g n e d S h o r t %
4179% %
4180% %
4181% %
4182%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4183%
4184% ReadBlobMSBSignedShort() reads a signed short value as a 16-bit quantity in
4185% most-significant byte-order.
4186%
4187% The format of the ReadBlobMSBSignedShort method is:
4188%
4189% signed short ReadBlobMSBSignedShort(Image *image)
4190%
4191% A description of each parameter follows.
4192%
4193% o image: the image.
4194%
4195*/
4196MagickExport signed short ReadBlobMSBSignedShort(Image *image)
4197{
4198 union
4199 {
4200 unsigned short
4201 unsigned_value;
4202
4203 signed short
4204 signed_value;
4205 } quantum;
4206
4207 quantum.unsigned_value=ReadBlobMSBShort(image);
4208 return(quantum.signed_value);
4209}
4210␌
4211/*
4212%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4213% %
4214% %
4215% %
4216+ R e a d B l o b S i g n e d L o n g %
4217% %
4218% %
4219% %
4220%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4221%
4222% ReadBlobSignedLong() reads a signed int value as a 32-bit quantity in the
4223% byte-order specified by the endian member of the image structure.
4224%
4225% The format of the ReadBlobSignedLong method is:
4226%
4227% signed int ReadBlobSignedLong(Image *image)
4228%
4229% A description of each parameter follows.
4230%
4231% o image: the image.
4232%
4233*/
4234MagickExport signed int ReadBlobSignedLong(Image *image)
4235{
4236 union
4237 {
4238 unsigned int
4239 unsigned_value;
4240
4241 signed int
4242 signed_value;
4243 } quantum;
4244
4245 quantum.unsigned_value=ReadBlobLong(image);
4246 return(quantum.signed_value);
4247}
4248␌
4249/*
4250%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4251% %
4252% %
4253% %
4254+ R e a d B l o b S i g n e d S h o r t %
4255% %
4256% %
4257% %
4258%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4259%
4260% ReadBlobSignedShort() reads a signed short value as a 16-bit quantity in the
4261% byte-order specified by the endian member of the image structure.
4262%
4263% The format of the ReadBlobSignedShort method is:
4264%
4265% signed short ReadBlobSignedShort(Image *image)
4266%
4267% A description of each parameter follows.
4268%
4269% o image: the image.
4270%
4271*/
4272MagickExport signed short ReadBlobSignedShort(Image *image)
4273{
4274 union
4275 {
4276 unsigned short
4277 unsigned_value;
4278
4279 signed short
4280 signed_value;
4281 } quantum;
4282
4283 quantum.unsigned_value=ReadBlobShort(image);
4284 return(quantum.signed_value);
4285}
4286␌
4287/*
4288%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4289% %
4290% %
4291% %
4292+ R e a d B l o b S t r e a m %
4293% %
4294% %
4295% %
4296%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4297%
4298% ReadBlobStream() reads data from the blob or image file and returns it. It
4299% returns a pointer to the data buffer you supply or to the image memory
4300% buffer if its supported (zero-copy). If length is zero, ReadBlobStream()
4301% returns a count of zero and has no other results. If length is greater than
4302% MAGICK_SSIZE_MAX, the result is unspecified.
4303%
4304% The format of the ReadBlobStream method is:
4305%
4306% const void *ReadBlobStream(Image *image,const size_t length,
4307% void *magick_restrict data,ssize_t *count)
4308%
4309% A description of each parameter follows:
4310%
4311% o image: the image.
4312%
4313% o length: Specifies an integer representing the number of bytes to read
4314% from the file.
4315%
4316% o count: returns the number of bytes read.
4317%
4318% o data: Specifies an area to place the information requested from the
4319% file.
4320%
4321*/
4322MagickExport magick_hot_spot const void *ReadBlobStream(Image *image,
4323 const size_t length,void *magick_restrict data,ssize_t *count)
4324{
4325 BlobInfo
4326 *magick_restrict blob_info;
4327
4328 assert(image != (Image *) NULL);
4329 assert(image->signature == MagickCoreSignature);
4330 assert(image->blob != (BlobInfo *) NULL);
4331 assert(image->blob->type != UndefinedStream);
4332 assert(count != (ssize_t *) NULL);
4333 blob_info=image->blob;
4334 if (blob_info->type != BlobStream)
4335 {
4336 assert(data != NULL);
4337 *count=ReadBlob(image,length,(unsigned char *) data);
4338 return(data);
4339 }
4340 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
4341 {
4342 *count=0;
4343 blob_info->eof=MagickTrue;
4344 return(data);
4345 }
4346 data=blob_info->data+blob_info->offset;
4347 *count=(ssize_t) MagickMin((MagickOffsetType) length,(MagickOffsetType)
4348 blob_info->length-blob_info->offset);
4349 blob_info->offset+=(*count);
4350 if (*count != (ssize_t) length)
4351 blob_info->eof=MagickTrue;
4352 return(data);
4353}
4354␌
4355/*
4356%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4357% %
4358% %
4359% %
4360+ R e a d B l o b S t r i n g %
4361% %
4362% %
4363% %
4364%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4365%
4366% ReadBlobString() reads characters from a blob or file until a newline
4367% character is read or an end-of-file condition is encountered.
4368%
4369% The format of the ReadBlobString method is:
4370%
4371% char *ReadBlobString(Image *image,char *string)
4372%
4373% A description of each parameter follows:
4374%
4375% o image: the image.
4376%
4377% o string: the address of a character buffer.
4378%
4379*/
4380MagickExport char *ReadBlobString(Image *image,char *string)
4381{
4382 BlobInfo
4383 *magick_restrict blob_info;
4384
4385 int
4386 c = -1;
4387
4388 ssize_t
4389 i = 0;
4390
4391 assert(image != (Image *) NULL);
4392 assert(image->signature == MagickCoreSignature);
4393 assert(image->blob != (BlobInfo *) NULL);
4394 assert(image->blob->type != UndefinedStream);
4395 if (IsEventLogging() != MagickFalse)
4396 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4397 *string='\0';
4398 blob_info=image->blob;
4399 switch (blob_info->type)
4400 {
4401 case UndefinedStream:
4402 break;
4403 case StandardStream:
4404 case FileStream:
4405 {
4406 char *p = fgets(string,MagickPathExtent,blob_info->file_info.file);
4407 if (p == (char *) NULL)
4408 {
4409 if (ferror(blob_info->file_info.file) != 0)
4410 ThrowBlobException(blob_info);
4411 return((char *) NULL);
4412 }
4413 i=strlen(string);
4414 break;
4415 }
4416 case ZipStream:
4417 {
4418#if defined(MAGICKCORE_ZLIB_DELEGATE)
4419 char *p = gzgets(blob_info->file_info.gzfile,string,MagickPathExtent);
4420 if (p == (char *) NULL)
4421 {
4422 int status = Z_OK;
4423 (void) gzerror(blob_info->file_info.gzfile,&status);
4424 if (status != Z_OK)
4425 ThrowBlobException(blob_info);
4426 return((char *) NULL);
4427 }
4428 i=strlen(string);
4429 break;
4430#endif
4431 }
4432 default:
4433 {
4434 do
4435 {
4436 c=ReadBlobByte(image);
4437 if (c == EOF)
4438 {
4439 blob_info->eof=MagickTrue;
4440 break;
4441 }
4442 string[i++]=c;
4443 if (c == '\n')
4444 break;
4445 } while (i < (MaxTextExtent-2));
4446 string[i]='\0';
4447 break;
4448 }
4449 }
4450 /*
4451 Strip trailing newline.
4452 */
4453 if ((string[i] == '\r') || (string[i] == '\n'))
4454 string[i]='\0';
4455 if (i >= 1)
4456 if ((string[i-1] == '\r') || (string[i-1] == '\n'))
4457 string[i-1]='\0';
4458 if ((*string == '\0') && (blob_info->eof != MagickFalse))
4459 return((char *) NULL);
4460 return(string);
4461}
4462␌
4463/*
4464%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4465% %
4466% %
4467% %
4468+ R e f e r e n c e B l o b %
4469% %
4470% %
4471% %
4472%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4473%
4474% ReferenceBlob() increments the reference count associated with the pixel
4475% blob returning a pointer to the blob.
4476%
4477% The format of the ReferenceBlob method is:
4478%
4479% BlobInfo ReferenceBlob(BlobInfo *blob_info)
4480%
4481% A description of each parameter follows:
4482%
4483% o blob_info: the blob_info.
4484%
4485*/
4486MagickExport BlobInfo *ReferenceBlob(BlobInfo *blob)
4487{
4488 assert(blob != (BlobInfo *) NULL);
4489 assert(blob->signature == MagickCoreSignature);
4490 if (IsEventLogging() != MagickFalse)
4491 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
4492 LockSemaphoreInfo(blob->semaphore);
4493 blob->reference_count++;
4494 UnlockSemaphoreInfo(blob->semaphore);
4495 return(blob);
4496}
4497␌
4498/*
4499%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4500% %
4501% %
4502% %
4503+ S e e k B l o b %
4504% %
4505% %
4506% %
4507%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4508%
4509% SeekBlob() sets the offset in bytes from the beginning of a blob or file
4510% and returns the resulting offset.
4511%
4512% The format of the SeekBlob method is:
4513%
4514% MagickOffsetType SeekBlob(Image *image,const MagickOffsetType offset,
4515% const int whence)
4516%
4517% A description of each parameter follows:
4518%
4519% o image: the image.
4520%
4521% o offset: Specifies an integer representing the offset in bytes.
4522%
4523% o whence: Specifies an integer representing how the offset is
4524% treated relative to the beginning of the blob as follows:
4525%
4526% SEEK_SET Set position equal to offset bytes.
4527% SEEK_CUR Set position to current location plus offset.
4528% SEEK_END Set position to EOF plus offset.
4529%
4530*/
4531MagickExport MagickOffsetType SeekBlob(Image *image,
4532 const MagickOffsetType offset,const int whence)
4533{
4534 BlobInfo
4535 *magick_restrict blob_info;
4536
4537 assert(image != (Image *) NULL);
4538 assert(image->signature == MagickCoreSignature);
4539 assert(image->blob != (BlobInfo *) NULL);
4540 assert(image->blob->type != UndefinedStream);
4541 if (IsEventLogging() != MagickFalse)
4542 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4543 blob_info=image->blob;
4544 switch (blob_info->type)
4545 {
4546 case UndefinedStream:
4547 break;
4548 case StandardStream:
4549 case PipeStream:
4550 return(-1);
4551 case FileStream:
4552 {
4553 if ((offset < 0) && (whence == SEEK_SET))
4554 return(-1);
4555 if (fseek(blob_info->file_info.file,offset,whence) < 0)
4556 return(-1);
4557 blob_info->offset=TellBlob(image);
4558 break;
4559 }
4560 case ZipStream:
4561 {
4562#if defined(MAGICKCORE_ZLIB_DELEGATE)
4563 if (gzseek(blob_info->file_info.gzfile,offset,whence) < 0)
4564 return(-1);
4565#endif
4566 blob_info->offset=TellBlob(image);
4567 break;
4568 }
4569 case BZipStream:
4570 return(-1);
4571 case FifoStream:
4572 return(-1);
4573 case BlobStream:
4574 {
4575 switch (whence)
4576 {
4577 case SEEK_SET:
4578 default:
4579 {
4580 if (offset < 0)
4581 return(-1);
4582 blob_info->offset=offset;
4583 break;
4584 }
4585 case SEEK_CUR:
4586 {
4587 if (((offset > 0) && (blob_info->offset > (MAGICK_SSIZE_MAX-offset))) ||
4588 ((offset < 0) && (blob_info->offset < (MAGICK_SSIZE_MIN-offset))))
4589 {
4590 errno=EOVERFLOW;
4591 return(-1);
4592 }
4593 if ((blob_info->offset+offset) < 0)
4594 return(-1);
4595 blob_info->offset+=offset;
4596 break;
4597 }
4598 case SEEK_END:
4599 {
4600 if (((MagickOffsetType) blob_info->length+offset) < 0)
4601 return(-1);
4602 blob_info->offset=blob_info->length+offset;
4603 break;
4604 }
4605 }
4606 if (blob_info->offset < (MagickOffsetType) ((off_t) blob_info->length))
4607 {
4608 blob_info->eof=MagickFalse;
4609 break;
4610 }
4611 break;
4612 }
4613 }
4614 return(blob_info->offset);
4615}
4616␌
4617/*
4618%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4619% %
4620% %
4621% %
4622+ S e t B l o b E x e m p t %
4623% %
4624% %
4625% %
4626%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4627%
4628% SetBlobExempt() sets the blob exempt status.
4629%
4630% The format of the SetBlobExempt method is:
4631%
4632% MagickBooleanType SetBlobExempt(const Image *image,
4633% const MagickBooleanType exempt)
4634%
4635% A description of each parameter follows:
4636%
4637% o image: the image.
4638%
4639% o exempt: Set to true if this blob is exempt from being closed.
4640%
4641*/
4642MagickExport void SetBlobExempt(Image *image,const MagickBooleanType exempt)
4643{
4644 assert(image != (const Image *) NULL);
4645 assert(image->signature == MagickCoreSignature);
4646 if (IsEventLogging() != MagickFalse)
4647 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4648 image->blob->exempt=exempt;
4649}
4650␌
4651/*
4652%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4653% %
4654% %
4655% %
4656+ S e t B l o b E x t e n t %
4657% %
4658% %
4659% %
4660%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4661%
4662% SetBlobExtent() ensures enough space is allocated for the blob. If the
4663% method is successful, subsequent writes to bytes in the specified range are
4664% guaranteed not to fail.
4665%
4666% The format of the SetBlobExtent method is:
4667%
4668% MagickBooleanType SetBlobExtent(Image *image,const MagickSizeType extent)
4669%
4670% A description of each parameter follows:
4671%
4672% o image: the image.
4673%
4674% o extent: the blob maximum extent.
4675%
4676*/
4677MagickExport MagickBooleanType SetBlobExtent(Image *image,
4678 const MagickSizeType extent)
4679{
4680 BlobInfo
4681 *magick_restrict blob_info;
4682
4683 assert(image != (Image *) NULL);
4684 assert(image->signature == MagickCoreSignature);
4685 assert(image->blob != (BlobInfo *) NULL);
4686 assert(image->blob->type != UndefinedStream);
4687 if (IsEventLogging() != MagickFalse)
4688 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4689 blob_info=image->blob;
4690 switch (blob_info->type)
4691 {
4692 case UndefinedStream:
4693 break;
4694 case StandardStream:
4695 return(MagickFalse);
4696 case FileStream:
4697 {
4698 MagickOffsetType
4699 offset;
4700
4701 ssize_t
4702 count;
4703
4704 if (extent != (MagickSizeType) ((off_t) extent))
4705 return(MagickFalse);
4706 offset=SeekBlob(image,0,SEEK_END);
4707 if (offset < 0)
4708 return(MagickFalse);
4709 if ((MagickSizeType) offset >= extent)
4710 break;
4711 offset=SeekBlob(image,(MagickOffsetType) extent-1,SEEK_SET);
4712 if (offset < 0)
4713 break;
4714 count=(ssize_t) fwrite((const unsigned char *) "",1,1,
4715 blob_info->file_info.file);
4716#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
4717 if (blob_info->synchronize != MagickFalse)
4718 {
4719 int
4720 file;
4721
4722 file=fileno(blob_info->file_info.file);
4723 if ((file == -1) || (offset < 0))
4724 return(MagickFalse);
4725 (void) posix_fallocate(file,offset,extent-offset);
4726 }
4727#endif
4728 offset=SeekBlob(image,offset,SEEK_SET);
4729 if (count != 1)
4730 return(MagickFalse);
4731 break;
4732 }
4733 case PipeStream:
4734 case ZipStream:
4735 return(MagickFalse);
4736 case BZipStream:
4737 return(MagickFalse);
4738 case FifoStream:
4739 return(MagickFalse);
4740 case BlobStream:
4741 {
4742 if (extent != (MagickSizeType) ((size_t) extent))
4743 return(MagickFalse);
4744 if (blob_info->mapped != MagickFalse)
4745 {
4746 MagickOffsetType
4747 offset;
4748
4749 ssize_t
4750 count;
4751
4752 (void) UnmapBlob(blob_info->data,blob_info->length);
4753 RelinquishMagickResource(MapResource,blob_info->length);
4754 if (extent != (MagickSizeType) ((off_t) extent))
4755 return(MagickFalse);
4756 offset=SeekBlob(image,0,SEEK_END);
4757 if (offset < 0)
4758 return(MagickFalse);
4759 if ((MagickSizeType) offset >= extent)
4760 break;
4761 offset=SeekBlob(image,(MagickOffsetType) extent-1,SEEK_SET);
4762 count=(ssize_t) fwrite((const unsigned char *) "",1,1,
4763 blob_info->file_info.file);
4764#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
4765 if (blob_info->synchronize != MagickFalse)
4766 {
4767 int
4768 file;
4769
4770 file=fileno(blob_info->file_info.file);
4771 if ((file == -1) || (offset < 0))
4772 return(MagickFalse);
4773 (void) posix_fallocate(file,offset,extent-offset);
4774 }
4775#endif
4776 offset=SeekBlob(image,offset,SEEK_SET);
4777 if (count != 1)
4778 return(MagickFalse);
4779 (void) AcquireMagickResource(MapResource,extent);
4780 blob_info->data=(unsigned char*) MapBlob(fileno(
4781 blob_info->file_info.file),WriteMode,0,(size_t) extent);
4782 blob_info->extent=(size_t) extent;
4783 blob_info->length=(size_t) extent;
4784 (void) SyncBlob(image);
4785 break;
4786 }
4787 blob_info->extent=(size_t) extent;
4788 blob_info->data=(unsigned char *) ResizeQuantumMemory(blob_info->data,
4789 blob_info->extent+1,sizeof(*blob_info->data));
4790 (void) SyncBlob(image);
4791 if (blob_info->data == (unsigned char *) NULL)
4792 {
4793 (void) DetachBlob(blob_info);
4794 return(MagickFalse);
4795 }
4796 break;
4797 }
4798 }
4799 return(MagickTrue);
4800}
4801␌
4802/*
4803%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4804% %
4805% %
4806% %
4807+ S y n c B l o b %
4808% %
4809% %
4810% %
4811%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4812%
4813% SyncBlob() flushes the datastream if it is a file or synchronizes the data
4814% attributes if it is an blob. It returns 0 on success; otherwise, it returns
4815% -1 and set errno to indicate the error.
4816%
4817% The format of the SyncBlob method is:
4818%
4819% int SyncBlob(const Image *image)
4820%
4821% A description of each parameter follows:
4822%
4823% o image: the image.
4824%
4825*/
4826static int SyncBlob(const Image *image)
4827{
4828 BlobInfo
4829 *magick_restrict blob_info;
4830
4831 int
4832 status;
4833
4834 assert(image != (Image *) NULL);
4835 assert(image->signature == MagickCoreSignature);
4836 assert(image->blob != (BlobInfo *) NULL);
4837 if (IsEventLogging() != MagickFalse)
4838 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4839 if (EOFBlob(image) != 0)
4840 return(0);
4841 blob_info=image->blob;
4842 status=0;
4843 switch (blob_info->type)
4844 {
4845 case UndefinedStream:
4846 case StandardStream:
4847 break;
4848 case FileStream:
4849 case PipeStream:
4850 {
4851 status=fflush(blob_info->file_info.file);
4852 break;
4853 }
4854 case ZipStream:
4855 {
4856#if defined(MAGICKCORE_ZLIB_DELEGATE)
4857 (void) gzflush(blob_info->file_info.gzfile,Z_SYNC_FLUSH);
4858#endif
4859 break;
4860 }
4861 case BZipStream:
4862 {
4863#if defined(MAGICKCORE_BZLIB_DELEGATE)
4864 status=BZ2_bzflush(blob_info->file_info.bzfile);
4865#endif
4866 break;
4867 }
4868 case FifoStream:
4869 break;
4870 case BlobStream:
4871 break;
4872 }
4873 return(status);
4874}
4875␌
4876/*
4877%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4878% %
4879% %
4880% %
4881+ T e l l B l o b %
4882% %
4883% %
4884% %
4885%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4886%
4887% TellBlob() obtains the current value of the blob or file position.
4888%
4889% The format of the TellBlob method is:
4890%
4891% MagickOffsetType TellBlob(const Image *image)
4892%
4893% A description of each parameter follows:
4894%
4895% o image: the image.
4896%
4897*/
4898MagickExport MagickOffsetType TellBlob(const Image *image)
4899{
4900 BlobInfo
4901 *magick_restrict blob_info;
4902
4903 MagickOffsetType
4904 offset;
4905
4906 assert(image != (Image *) NULL);
4907 assert(image->signature == MagickCoreSignature);
4908 assert(image->blob != (BlobInfo *) NULL);
4909 assert(image->blob->type != UndefinedStream);
4910 if (IsEventLogging() != MagickFalse)
4911 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
4912 blob_info=image->blob;
4913 offset=(-1);
4914 switch (blob_info->type)
4915 {
4916 case UndefinedStream:
4917 case StandardStream:
4918 break;
4919 case FileStream:
4920 {
4921 offset=ftell(blob_info->file_info.file);
4922 break;
4923 }
4924 case PipeStream:
4925 break;
4926 case ZipStream:
4927 {
4928#if defined(MAGICKCORE_ZLIB_DELEGATE)
4929 offset=(MagickOffsetType) gztell(blob_info->file_info.gzfile);
4930#endif
4931 break;
4932 }
4933 case BZipStream:
4934 break;
4935 case FifoStream:
4936 break;
4937 case BlobStream:
4938 {
4939 offset=blob_info->offset;
4940 break;
4941 }
4942 }
4943 return(offset);
4944}
4945␌
4946/*
4947%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4948% %
4949% %
4950% %
4951+ U n m a p B l o b %
4952% %
4953% %
4954% %
4955%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4956%
4957% UnmapBlob() deallocates the binary large object previously allocated with
4958% the MapBlob method.
4959%
4960% The format of the UnmapBlob method is:
4961%
4962% MagickBooleanType UnmapBlob(void *map,const size_t length)
4963%
4964% A description of each parameter follows:
4965%
4966% o map: the address of the binary large object.
4967%
4968% o length: the length of the binary large object.
4969%
4970*/
4971MagickExport MagickBooleanType UnmapBlob(void *map,const size_t length)
4972{
4973#if defined(MAGICKCORE_HAVE_MMAP)
4974 int
4975 status;
4976
4977 status=munmap(map,length);
4978 return(status == -1 ? MagickFalse : MagickTrue);
4979#else
4980 (void) map;
4981 (void) length;
4982 return(MagickFalse);
4983#endif
4984}
4985␌
4986/*
4987%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4988% %
4989% %
4990% %
4991+ W r i t e B l o b %
4992% %
4993% %
4994% %
4995%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4996%
4997% WriteBlob() writes data to a blob or image file. It returns the number of
4998% bytes written.
4999%
5000% The format of the WriteBlob method is:
5001%
5002% ssize_t WriteBlob(Image *image,const size_t length,
5003% const unsigned char *data)
5004%
5005% A description of each parameter follows:
5006%
5007% o image: the image.
5008%
5009% o length: Specifies an integer representing the number of bytes to
5010% write to the file.
5011%
5012% o data: The address of the data to write to the blob or file.
5013%
5014*/
5015MagickExport ssize_t WriteBlob(Image *image,const size_t length,
5016 const unsigned char *data)
5017{
5018 BlobInfo
5019 *magick_restrict blob_info;
5020
5021 int
5022 c;
5023
5024 const unsigned char
5025 *p;
5026
5027 unsigned char
5028 *q;
5029
5030 ssize_t
5031 count;
5032
5033 assert(image != (Image *) NULL);
5034 assert(image->signature == MagickCoreSignature);
5035 assert(image->blob != (BlobInfo *) NULL);
5036 assert(image->blob->type != UndefinedStream);
5037 if (length == 0)
5038 return(0);
5039 assert(data != (const unsigned char *) NULL);
5040 blob_info=image->blob;
5041 count=0;
5042 p=(const unsigned char *) data;
5043 q=(unsigned char *) data;
5044 switch (blob_info->type)
5045 {
5046 case UndefinedStream:
5047 break;
5048 case StandardStream:
5049 case FileStream:
5050 case PipeStream:
5051 {
5052 switch (length)
5053 {
5054 default:
5055 {
5056 count=(ssize_t) fwrite((const char *) data,1,length,
5057 blob_info->file_info.file);
5058 break;
5059 }
5060 case 4:
5061 {
5062 c=putc((int) *p++,blob_info->file_info.file);
5063 if (c == EOF)
5064 break;
5065 count++;
5066 magick_fallthrough;
5067 }
5068 case 3:
5069 {
5070 c=putc((int) *p++,blob_info->file_info.file);
5071 if (c == EOF)
5072 break;
5073 count++;
5074 magick_fallthrough;
5075 }
5076 case 2:
5077 {
5078 c=putc((int) *p++,blob_info->file_info.file);
5079 if (c == EOF)
5080 break;
5081 count++;
5082 magick_fallthrough;
5083 }
5084 case 1:
5085 {
5086 c=putc((int) *p++,blob_info->file_info.file);
5087 if (c == EOF)
5088 break;
5089 count++;
5090 magick_fallthrough;
5091 }
5092 case 0:
5093 break;
5094 }
5095 if ((count != (ssize_t) length) &&
5096 (ferror(blob_info->file_info.file) != 0))
5097 ThrowBlobException(blob_info);
5098 break;
5099 }
5100 case ZipStream:
5101 {
5102#if defined(MAGICKCORE_ZLIB_DELEGATE)
5103 int
5104 status;
5105
5106 switch (length)
5107 {
5108 default:
5109 {
5110 ssize_t
5111 i;
5112
5113 for (i=0; i < (ssize_t) length; i+=count)
5114 {
5115 count=(ssize_t) gzwrite(blob_info->file_info.gzfile,q+i,
5116 (unsigned int) MagickMin(length-i,MagickMaxBufferExtent));
5117 if (count <= 0)
5118 {
5119 count=0;
5120 if (errno != EINTR)
5121 break;
5122 }
5123 }
5124 count=i;
5125 break;
5126 }
5127 case 4:
5128 {
5129 c=gzputc(blob_info->file_info.gzfile,(int) *p++);
5130 if (c == EOF)
5131 break;
5132 count++;
5133 magick_fallthrough;
5134 }
5135 case 3:
5136 {
5137 c=gzputc(blob_info->file_info.gzfile,(int) *p++);
5138 if (c == EOF)
5139 break;
5140 count++;
5141 magick_fallthrough;
5142 }
5143 case 2:
5144 {
5145 c=gzputc(blob_info->file_info.gzfile,(int) *p++);
5146 if (c == EOF)
5147 break;
5148 count++;
5149 magick_fallthrough;
5150 }
5151 case 1:
5152 {
5153 c=gzputc(blob_info->file_info.gzfile,(int) *p++);
5154 if (c == EOF)
5155 break;
5156 count++;
5157 magick_fallthrough;
5158 }
5159 case 0:
5160 break;
5161 }
5162 status=Z_OK;
5163 (void) gzerror(blob_info->file_info.gzfile,&status);
5164 if ((count != (ssize_t) length) && (status != Z_OK))
5165 ThrowBlobException(blob_info);
5166#endif
5167 break;
5168 }
5169 case BZipStream:
5170 {
5171#if defined(MAGICKCORE_BZLIB_DELEGATE)
5172 int
5173 status;
5174
5175 ssize_t
5176 i;
5177
5178 for (i=0; i < (ssize_t) length; i+=count)
5179 {
5180 count=(ssize_t) BZ2_bzwrite(blob_info->file_info.bzfile,q+i,
5181 (int) MagickMin(length-i,MagickMaxBufferExtent));
5182 if (count <= 0)
5183 {
5184 count=0;
5185 if (errno != EINTR)
5186 break;
5187 }
5188 }
5189 count=i;
5190 status=BZ_OK;
5191 (void) BZ2_bzerror(blob_info->file_info.bzfile,&status);
5192 if ((count != (ssize_t) length) && (status != BZ_OK))
5193 ThrowBlobException(blob_info);
5194#endif
5195 break;
5196 }
5197 case FifoStream:
5198 {
5199 count=(ssize_t) blob_info->stream(image,data,length);
5200 break;
5201 }
5202 case BlobStream:
5203 {
5204 MagickSizeType
5205 extent;
5206
5207 if (blob_info->offset > (MagickOffsetType) (MAGICK_SSIZE_MAX-length))
5208 {
5209 errno=EOVERFLOW;
5210 return(0);
5211 }
5212 extent=(MagickSizeType) (blob_info->offset+(MagickOffsetType) length);
5213 if (extent >= blob_info->extent)
5214 {
5215 extent+=blob_info->quantum+length;
5216 blob_info->quantum<<=1;
5217 if (SetBlobExtent(image,extent) == MagickFalse)
5218 return(0);
5219 }
5220 q=blob_info->data+blob_info->offset;
5221 (void) memcpy(q,p,length);
5222 blob_info->offset+=length;
5223 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
5224 blob_info->length=(size_t) blob_info->offset;
5225 count=(ssize_t) length;
5226 }
5227 }
5228 if (count != (ssize_t) length)
5229 ThrowBlobException(blob_info);
5230 return(count);
5231}
5232␌
5233/*
5234%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5235% %
5236% %
5237% %
5238+ W r i t e B l o b B y t e %
5239% %
5240% %
5241% %
5242%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5243%
5244% WriteBlobByte() write an integer to a blob. It returns the number of bytes
5245% written (either 0 or 1);
5246%
5247% The format of the WriteBlobByte method is:
5248%
5249% ssize_t WriteBlobByte(Image *image,const unsigned char value)
5250%
5251% A description of each parameter follows.
5252%
5253% o image: the image.
5254%
5255% o value: Specifies the value to write.
5256%
5257*/
5258MagickExport ssize_t WriteBlobByte(Image *image,const unsigned char value)
5259{
5260 BlobInfo
5261 *magick_restrict blob_info;
5262
5263 ssize_t
5264 count;
5265
5266 assert(image != (Image *) NULL);
5267 assert(image->signature == MagickCoreSignature);
5268 assert(image->blob != (BlobInfo *) NULL);
5269 assert(image->blob->type != UndefinedStream);
5270 blob_info=image->blob;
5271 count=0;
5272 switch (blob_info->type)
5273 {
5274 case StandardStream:
5275 case FileStream:
5276 case PipeStream:
5277 {
5278 int
5279 c;
5280
5281 c=putc((int) value,blob_info->file_info.file);
5282 if (c == EOF)
5283 {
5284 if (ferror(blob_info->file_info.file) != 0)
5285 ThrowBlobException(blob_info);
5286 break;
5287 }
5288 count++;
5289 break;
5290 }
5291 default:
5292 {
5293 count=WriteBlobStream(image,1,&value);
5294 break;
5295 }
5296 }
5297 return(count);
5298}
5299␌
5300/*
5301%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5302% %
5303% %
5304% %
5305+ W r i t e B l o b F l o a t %
5306% %
5307% %
5308% %
5309%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5310%
5311% WriteBlobFloat() writes a float value as a 32-bit quantity in the byte-order
5312% specified by the endian member of the image structure.
5313%
5314% The format of the WriteBlobFloat method is:
5315%
5316% ssize_t WriteBlobFloat(Image *image,const float value)
5317%
5318% A description of each parameter follows.
5319%
5320% o image: the image.
5321%
5322% o value: Specifies the value to write.
5323%
5324*/
5325MagickExport ssize_t WriteBlobFloat(Image *image,const float value)
5326{
5327 union
5328 {
5329 unsigned int
5330 unsigned_value;
5331
5332 float
5333 float_value;
5334 } quantum;
5335
5336 quantum.unsigned_value=0U;
5337 quantum.float_value=value;
5338 return(WriteBlobLong(image,quantum.unsigned_value));
5339}
5340␌
5341/*
5342%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5343% %
5344% %
5345% %
5346+ W r i t e B l o b L o n g %
5347% %
5348% %
5349% %
5350%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5351%
5352% WriteBlobLong() writes a unsigned int value as a 32-bit quantity in the
5353% byte-order specified by the endian member of the image structure.
5354%
5355% The format of the WriteBlobLong method is:
5356%
5357% ssize_t WriteBlobLong(Image *image,const unsigned int value)
5358%
5359% A description of each parameter follows.
5360%
5361% o image: the image.
5362%
5363% o value: Specifies the value to write.
5364%
5365*/
5366MagickExport ssize_t WriteBlobLong(Image *image,const unsigned int value)
5367{
5368 unsigned char
5369 buffer[4];
5370
5371 assert(image != (Image *) NULL);
5372 assert(image->signature == MagickCoreSignature);
5373 if (image->endian == LSBEndian)
5374 {
5375 buffer[0]=(unsigned char) value;
5376 buffer[1]=(unsigned char) (value >> 8);
5377 buffer[2]=(unsigned char) (value >> 16);
5378 buffer[3]=(unsigned char) (value >> 24);
5379 return(WriteBlobStream(image,4,buffer));
5380 }
5381 buffer[0]=(unsigned char) (value >> 24);
5382 buffer[1]=(unsigned char) (value >> 16);
5383 buffer[2]=(unsigned char) (value >> 8);
5384 buffer[3]=(unsigned char) value;
5385 return(WriteBlobStream(image,4,buffer));
5386}
5387␌
5388/*
5389%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5390% %
5391% %
5392% %
5393+ W r i t e B l o b S h o r t %
5394% %
5395% %
5396% %
5397%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5398%
5399% WriteBlobShort() writes a short value as a 16-bit quantity in the
5400% byte-order specified by the endian member of the image structure.
5401%
5402% The format of the WriteBlobShort method is:
5403%
5404% ssize_t WriteBlobShort(Image *image,const unsigned short value)
5405%
5406% A description of each parameter follows.
5407%
5408% o image: the image.
5409%
5410% o value: Specifies the value to write.
5411%
5412*/
5413MagickExport ssize_t WriteBlobShort(Image *image,const unsigned short value)
5414{
5415 unsigned char
5416 buffer[2];
5417
5418 assert(image != (Image *) NULL);
5419 assert(image->signature == MagickCoreSignature);
5420 if (image->endian == LSBEndian)
5421 {
5422 buffer[0]=(unsigned char) value;
5423 buffer[1]=(unsigned char) (value >> 8);
5424 return(WriteBlobStream(image,2,buffer));
5425 }
5426 buffer[0]=(unsigned char) (value >> 8);
5427 buffer[1]=(unsigned char) value;
5428 return(WriteBlobStream(image,2,buffer));
5429}
5430␌
5431/*
5432%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5433% %
5434% %
5435% %
5436+ W r i t e B l o b L S B L o n g %
5437% %
5438% %
5439% %
5440%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5441%
5442% WriteBlobLSBLong() writes a unsigned int value as a 32-bit quantity in
5443% least-significant byte first order.
5444%
5445% The format of the WriteBlobLSBLong method is:
5446%
5447% ssize_t WriteBlobLSBLong(Image *image,const unsigned int value)
5448%
5449% A description of each parameter follows.
5450%
5451% o image: the image.
5452%
5453% o value: Specifies the value to write.
5454%
5455*/
5456MagickExport ssize_t WriteBlobLSBLong(Image *image,const unsigned int value)
5457{
5458 unsigned char
5459 buffer[4];
5460
5461 assert(image != (Image *) NULL);
5462 assert(image->signature == MagickCoreSignature);
5463 buffer[0]=(unsigned char) value;
5464 buffer[1]=(unsigned char) (value >> 8);
5465 buffer[2]=(unsigned char) (value >> 16);
5466 buffer[3]=(unsigned char) (value >> 24);
5467 return(WriteBlobStream(image,4,buffer));
5468}
5469␌
5470/*
5471%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5472% %
5473% %
5474% %
5475+ W r i t e B l o b L S B S h o r t %
5476% %
5477% %
5478% %
5479%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5480%
5481% WriteBlobLSBShort() writes a unsigned short value as a 16-bit quantity in
5482% least-significant byte first order.
5483%
5484% The format of the WriteBlobLSBShort method is:
5485%
5486% ssize_t WriteBlobLSBShort(Image *image,const unsigned short value)
5487%
5488% A description of each parameter follows.
5489%
5490% o image: the image.
5491%
5492% o value: Specifies the value to write.
5493%
5494*/
5495MagickExport ssize_t WriteBlobLSBShort(Image *image,const unsigned short value)
5496{
5497 unsigned char
5498 buffer[2];
5499
5500 assert(image != (Image *) NULL);
5501 assert(image->signature == MagickCoreSignature);
5502 buffer[0]=(unsigned char) value;
5503 buffer[1]=(unsigned char) (value >> 8);
5504 return(WriteBlobStream(image,2,buffer));
5505}
5506␌
5507/*
5508%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5509% %
5510% %
5511% %
5512+ W r i t e B l o b L S B S i g n e d L o n g %
5513% %
5514% %
5515% %
5516%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5517%
5518% WriteBlobLSBSignedLong() writes a signed value as a 32-bit quantity in
5519% least-significant byte first order.
5520%
5521% The format of the WriteBlobLSBSignedLong method is:
5522%
5523% ssize_t WriteBlobLSBSignedLong(Image *image,const signed int value)
5524%
5525% A description of each parameter follows.
5526%
5527% o image: the image.
5528%
5529% o value: Specifies the value to write.
5530%
5531*/
5532MagickExport ssize_t WriteBlobLSBSignedLong(Image *image,const signed int value)
5533{
5534 union
5535 {
5536 unsigned int
5537 unsigned_value;
5538
5539 signed int
5540 signed_value;
5541 } quantum;
5542
5543 unsigned char
5544 buffer[4];
5545
5546 assert(image != (Image *) NULL);
5547 assert(image->signature == MagickCoreSignature);
5548 quantum.signed_value=value;
5549 buffer[0]=(unsigned char) quantum.unsigned_value;
5550 buffer[1]=(unsigned char) (quantum.unsigned_value >> 8);
5551 buffer[2]=(unsigned char) (quantum.unsigned_value >> 16);
5552 buffer[3]=(unsigned char) (quantum.unsigned_value >> 24);
5553 return(WriteBlobStream(image,4,buffer));
5554}
5555␌
5556/*
5557%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5558% %
5559% %
5560% %
5561+ W r i t e B l o b L S B S i g n e d S h o r t %
5562% %
5563% %
5564% %
5565%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5566%
5567% WriteBlobLSBSignedShort() writes a signed short value as a 16-bit quantity
5568% in least-significant byte first order.
5569%
5570% The format of the WriteBlobLSBSignedShort method is:
5571%
5572% ssize_t WriteBlobLSBSignedShort(Image *image,const signed short value)
5573%
5574% A description of each parameter follows.
5575%
5576% o image: the image.
5577%
5578% o value: Specifies the value to write.
5579%
5580*/
5581MagickExport ssize_t WriteBlobLSBSignedShort(Image *image,
5582 const signed short value)
5583{
5584 union
5585 {
5586 unsigned short
5587 unsigned_value;
5588
5589 signed short
5590 signed_value;
5591 } quantum;
5592
5593 unsigned char
5594 buffer[2];
5595
5596 assert(image != (Image *) NULL);
5597 assert(image->signature == MagickCoreSignature);
5598 quantum.signed_value=value;
5599 buffer[0]=(unsigned char) quantum.unsigned_value;
5600 buffer[1]=(unsigned char) (quantum.unsigned_value >> 8);
5601 return(WriteBlobStream(image,2,buffer));
5602}
5603␌
5604/*
5605%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5606% %
5607% %
5608% %
5609+ W r i t e B l o b M S B L o n g %
5610% %
5611% %
5612% %
5613%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5614%
5615% WriteBlobMSBLong() writes a unsigned int value as a 32-bit quantity in
5616% most-significant byte first order.
5617%
5618% The format of the WriteBlobMSBLong method is:
5619%
5620% ssize_t WriteBlobMSBLong(Image *image,const unsigned int value)
5621%
5622% A description of each parameter follows.
5623%
5624% o value: Specifies the value to write.
5625%
5626% o image: the image.
5627%
5628*/
5629MagickExport ssize_t WriteBlobMSBLong(Image *image,const unsigned int value)
5630{
5631 unsigned char
5632 buffer[4];
5633
5634 assert(image != (Image *) NULL);
5635 assert(image->signature == MagickCoreSignature);
5636 buffer[0]=(unsigned char) (value >> 24);
5637 buffer[1]=(unsigned char) (value >> 16);
5638 buffer[2]=(unsigned char) (value >> 8);
5639 buffer[3]=(unsigned char) value;
5640 return(WriteBlobStream(image,4,buffer));
5641}
5642␌
5643/*
5644%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5645% %
5646% %
5647% %
5648+ W r i t e B l o b M S B L o n g L o n g %
5649% %
5650% %
5651% %
5652%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5653%
5654% WriteBlobMSBLongLong() writes a long long value as a 64-bit quantity in
5655% most-significant byte first order.
5656%
5657% The format of the WriteBlobMSBLongLong method is:
5658%
5659% ssize_t WriteBlobMSBLongLong(Image *image,const MagickSizeType value)
5660%
5661% A description of each parameter follows.
5662%
5663% o value: Specifies the value to write.
5664%
5665% o image: the image.
5666%
5667*/
5668MagickExport ssize_t WriteBlobMSBLongLong(Image *image,
5669 const MagickSizeType value)
5670{
5671 unsigned char
5672 buffer[8];
5673
5674 assert(image != (Image *) NULL);
5675 assert(image->signature == MagickCoreSignature);
5676 buffer[0]=(unsigned char) (value >> 56);
5677 buffer[1]=(unsigned char) (value >> 48);
5678 buffer[2]=(unsigned char) (value >> 40);
5679 buffer[3]=(unsigned char) (value >> 32);
5680 buffer[4]=(unsigned char) (value >> 24);
5681 buffer[5]=(unsigned char) (value >> 16);
5682 buffer[6]=(unsigned char) (value >> 8);
5683 buffer[7]=(unsigned char) value;
5684 return(WriteBlobStream(image,8,buffer));
5685}
5686␌
5687/*
5688%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5689% %
5690% %
5691% %
5692+ W r i t e B l o b M S B S h o r t %
5693% %
5694% %
5695% %
5696%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5697%
5698% WriteBlobMSBShort() writes a unsigned short value as a 16-bit quantity in
5699% most-significant byte first order.
5700%
5701% The format of the WriteBlobMSBShort method is:
5702%
5703% ssize_t WriteBlobMSBShort(Image *image,const unsigned short value)
5704%
5705% A description of each parameter follows.
5706%
5707% o value: Specifies the value to write.
5708%
5709% o file: Specifies the file to write the data to.
5710%
5711*/
5712MagickExport ssize_t WriteBlobMSBShort(Image *image,const unsigned short value)
5713{
5714 unsigned char
5715 buffer[2];
5716
5717 assert(image != (Image *) NULL);
5718 assert(image->signature == MagickCoreSignature);
5719 buffer[0]=(unsigned char) (value >> 8);
5720 buffer[1]=(unsigned char) value;
5721 return(WriteBlobStream(image,2,buffer));
5722}
5723␌
5724/*
5725%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5726% %
5727% %
5728% %
5729+ W r i t e B l o b M S B S i g n e d L o n g %
5730% %
5731% %
5732% %
5733%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5734%
5735% WriteBlobMSBSignedLong() writes a signed value as a 32-bit quantity in
5736% most-significant byte first order.
5737%
5738% The format of the WriteBlobMSBSignedLong method is:
5739%
5740% ssize_t WriteBlobMSBSignedLong(Image *image,const signed int value)
5741%
5742% A description of each parameter follows.
5743%
5744% o image: the image.
5745%
5746% o value: Specifies the value to write.
5747%
5748*/
5749MagickExport ssize_t WriteBlobMSBSignedLong(Image *image,const signed int value)
5750{
5751 union
5752 {
5753 unsigned int
5754 unsigned_value;
5755
5756 signed int
5757 signed_value;
5758 } quantum;
5759
5760 unsigned char
5761 buffer[4];
5762
5763 assert(image != (Image *) NULL);
5764 assert(image->signature == MagickCoreSignature);
5765 quantum.signed_value=value;
5766 buffer[0]=(unsigned char) (quantum.unsigned_value >> 24);
5767 buffer[1]=(unsigned char) (quantum.unsigned_value >> 16);
5768 buffer[2]=(unsigned char) (quantum.unsigned_value >> 8);
5769 buffer[3]=(unsigned char) quantum.unsigned_value;
5770 return(WriteBlobStream(image,4,buffer));
5771}
5772␌
5773/*
5774%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5775% %
5776% %
5777% %
5778+ W r i t e B l o b M S B S i g n e d S h o r t %
5779% %
5780% %
5781% %
5782%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5783%
5784% WriteBlobMSBSignedShort() writes a signed short value as a 16-bit quantity
5785% in most-significant byte first order.
5786%
5787% The format of the WriteBlobMSBSignedShort method is:
5788%
5789% ssize_t WriteBlobMSBSignedShort(Image *image,const signed short value)
5790%
5791% A description of each parameter follows.
5792%
5793% o image: the image.
5794%
5795% o value: Specifies the value to write.
5796%
5797*/
5798MagickExport ssize_t WriteBlobMSBSignedShort(Image *image,
5799 const signed short value)
5800{
5801 union
5802 {
5803 unsigned short
5804 unsigned_value;
5805
5806 signed short
5807 signed_value;
5808 } quantum;
5809
5810 unsigned char
5811 buffer[2];
5812
5813 assert(image != (Image *) NULL);
5814 assert(image->signature == MagickCoreSignature);
5815 quantum.signed_value=value;
5816 buffer[0]=(unsigned char) (quantum.unsigned_value >> 8);
5817 buffer[1]=(unsigned char) quantum.unsigned_value;
5818 return(WriteBlobStream(image,2,buffer));
5819}
5820␌
5821/*
5822%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5823% %
5824% %
5825% %
5826+ W r i t e B l o b S t r i n g %
5827% %
5828% %
5829% %
5830%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5831%
5832% WriteBlobString() write a string to a blob. It returns the number of
5833% characters written.
5834%
5835% The format of the WriteBlobString method is:
5836%
5837% ssize_t WriteBlobString(Image *image,const char *string)
5838%
5839% A description of each parameter follows.
5840%
5841% o image: the image.
5842%
5843% o string: Specifies the string to write.
5844%
5845*/
5846MagickExport ssize_t WriteBlobString(Image *image,const char *string)
5847{
5848 assert(image != (Image *) NULL);
5849 assert(image->signature == MagickCoreSignature);
5850 assert(string != (const char *) NULL);
5851 return(WriteBlobStream(image,strlen(string),(const unsigned char *) string));
5852}
_BlobInfo
Definition blob.c:139