1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % V V IIIII PPPP SSSSS %
7 % V V I P P SS %
8 % V V I PPPP SSS %
9 % V V I P SS %
10 % V IIIII P SSSSS %
11 % %
12 % %
13 % Read/Write VIPS Image Format %
14 % %
15 % Software Design %
16 % Dirk Lemstra %
17 % April 2014 %
18 % %
19 % %
20 % Copyright 1999-2021 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
22 % %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
25 % %
26 % https://imagemagick.org/script/license.php %
27 % %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
33 % %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35 %
36 %
37 */
38
39 /*
40 Include declarations.
41 */
42 #include "MagickCore/studio.h"
43 #include "MagickCore/attribute.h"
44 #include "MagickCore/blob.h"
45 #include "MagickCore/blob-private.h"
46 #include "MagickCore/cache.h"
47 #include "MagickCore/colorspace.h"
48 #include "MagickCore/colorspace-private.h"
49 #include "MagickCore/exception.h"
50 #include "MagickCore/exception-private.h"
51 #include "MagickCore/image.h"
52 #include "MagickCore/image-private.h"
53 #include "MagickCore/list.h"
54 #include "MagickCore/magick.h"
55 #include "MagickCore/memory_.h"
56 #include "MagickCore/monitor.h"
57 #include "MagickCore/monitor-private.h"
58 #include "MagickCore/pixel-accessor.h"
59 #include "MagickCore/property.h"
60 #include "MagickCore/quantum-private.h"
61 #include "MagickCore/static.h"
62 #include "MagickCore/string_.h"
63 #include "MagickCore/module.h"
64
65 /*
66 Define declaractions.
67 */
68 #define VIPS_MAGIC_LSB 0x08f2a6b6U
69 #define VIPS_MAGIC_MSB 0xb6a6f208U
70
71 typedef enum
72 {
73 VIPSBandFormatNOTSET = -1,
74 VIPSBandFormatUCHAR = 0, /* Unsigned 8-bit int */
75 VIPSBandFormatCHAR = 1, /* Signed 8-bit int */
76 VIPSBandFormatUSHORT = 2, /* Unsigned 16-bit int */
77 VIPSBandFormatSHORT = 3, /* Signed 16-bit int */
78 VIPSBandFormatUINT = 4, /* Unsigned 32-bit int */
79 VIPSBandFormatINT = 5, /* Signed 32-bit int */
80 VIPSBandFormatFLOAT = 6, /* 32-bit IEEE float */
81 VIPSBandFormatCOMPLEX = 7, /* Complex (2 floats) */
82 VIPSBandFormatDOUBLE = 8, /* 64-bit IEEE double */
83 VIPSBandFormatDPCOMPLEX = 9 /* Complex (2 doubles) */
84 } VIPSBandFormat;
85
86 typedef enum
87 {
88 VIPSCodingNONE = 0, /* VIPS computation format */
89 VIPSCodingLABQ = 2, /* LABQ storage format */
90 VIPSCodingRAD = 6 /* Radiance storage format */
91 } VIPSCoding;
92
93 typedef enum
94 {
95 VIPSTypeMULTIBAND = 0, /* Some multiband image */
96 VIPSTypeB_W = 1, /* Some single band image */
97 VIPSTypeHISTOGRAM = 10, /* Histogram or LUT */
98 VIPSTypeFOURIER = 24, /* Image in Fourier space */
99 VIPSTypeXYZ = 12, /* CIE XYZ color space */
100 VIPSTypeLAB = 13, /* CIE LAB color space */
101 VIPSTypeCMYK = 15, /* im_icc_export() */
102 VIPSTypeLABQ = 16, /* 32-bit CIE LAB */
103 VIPSTypeRGB = 17, /* Some RGB */
104 VIPSTypeUCS = 18, /* UCS(1:1) color space */
105 VIPSTypeLCH = 19, /* CIE LCh color space */
106 VIPSTypeLABS = 21, /* 48-bit CIE LAB */
107 VIPSTypesRGB = 22, /* sRGB color space */
108 VIPSTypeYXY = 23, /* CIE Yxy color space */
109 VIPSTypeRGB16 = 25, /* 16-bit RGB */
110 VIPSTypeGREY16 = 26 /* 16-bit monochrome */
111 } VIPSType;
112
113 /*
114 Forward declarations.
115 */
116 static MagickBooleanType
117 WriteVIPSImage(const ImageInfo *,Image *,ExceptionInfo *);
118
119 /*
120 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
121 % %
122 % %
123 % %
124 % I s V I P S %
125 % %
126 % %
127 % %
128 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
129 %
130 % IsVIPS() returns MagickTrue if the image format type, identified by the
131 % magick string, is VIPS.
132 %
133 % The format of the IsVIPS method is:
134 %
135 % MagickBooleanType IsVIPS(const unsigned char *magick,const size_t length)
136 %
137 % A description of each parameter follows:
138 %
139 % o magick: compare image format pattern against these bytes.
140 %
141 % o length: Specifies the length of the magick string.
142 %
143 */
IsVIPS(const unsigned char * magick,const size_t length)144 static MagickBooleanType IsVIPS(const unsigned char *magick,const size_t length)
145 {
146 if (length < 4)
147 return(MagickFalse);
148
149 if (memcmp(magick,"\010\362\246\266",4) == 0)
150 return(MagickTrue);
151
152 if (memcmp(magick,"\266\246\362\010",4) == 0)
153 return(MagickTrue);
154
155 return(MagickFalse);
156 }
157
158 /*
159 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
160 % %
161 % %
162 % %
163 % R e a d V I P S I m a g e %
164 % %
165 % %
166 % %
167 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
168 %
169 % ReadVIPSImage() reads a VIPS image file and returns it. It allocates the
170 % memory necessary for the new Image structure and returns a pointer to the
171 % new image.
172 %
173 % The format of the ReadVIPSImage method is:
174 %
175 % Image *ReadVIPSmage(const ImageInfo *image_info,ExceptionInfo *exception)
176 %
177 % A description of each parameter follows:
178 %
179 % o image_info: the image info.
180 %
181 % o exception: return any errors or warnings in this structure.
182 %
183 */
184
IsSupportedCombination(const VIPSBandFormat format,const VIPSType type)185 static inline MagickBooleanType IsSupportedCombination(
186 const VIPSBandFormat format,const VIPSType type)
187 {
188 switch(type)
189 {
190 case VIPSTypeB_W:
191 case VIPSTypeCMYK:
192 case VIPSTypeRGB:
193 case VIPSTypesRGB:
194 return(MagickTrue);
195 case VIPSTypeGREY16:
196 case VIPSTypeRGB16:
197 switch(format)
198 {
199 case VIPSBandFormatUSHORT:
200 case VIPSBandFormatSHORT:
201 case VIPSBandFormatUINT:
202 case VIPSBandFormatINT:
203 case VIPSBandFormatFLOAT:
204 case VIPSBandFormatDOUBLE:
205 return(MagickTrue);
206 default:
207 return(MagickFalse);
208 }
209 default:
210 return(MagickFalse);
211 }
212 }
213
ReadVIPSPixelNONE(Image * image,const VIPSBandFormat format,const VIPSType type)214 static inline Quantum ReadVIPSPixelNONE(Image *image,
215 const VIPSBandFormat format,const VIPSType type)
216 {
217 switch(type)
218 {
219 case VIPSTypeB_W:
220 case VIPSTypeRGB:
221 {
222 unsigned char
223 c;
224
225 switch(format)
226 {
227 case VIPSBandFormatUCHAR:
228 case VIPSBandFormatCHAR:
229 c=(unsigned char) ReadBlobByte(image);
230 break;
231 case VIPSBandFormatUSHORT:
232 case VIPSBandFormatSHORT:
233 c=(unsigned char) ReadBlobShort(image);
234 break;
235 case VIPSBandFormatUINT:
236 case VIPSBandFormatINT:
237 c=(unsigned char) ReadBlobLong(image);
238 break;
239 case VIPSBandFormatFLOAT:
240 c=(unsigned char) ReadBlobFloat(image);
241 break;
242 case VIPSBandFormatDOUBLE:
243 c=(unsigned char) ReadBlobDouble(image);
244 break;
245 default:
246 c=0;
247 break;
248 }
249 return(ScaleCharToQuantum(c));
250 }
251 case VIPSTypeGREY16:
252 case VIPSTypeRGB16:
253 {
254 unsigned short
255 s;
256
257 switch(format)
258 {
259 case VIPSBandFormatUSHORT:
260 case VIPSBandFormatSHORT:
261 s=(unsigned short) ReadBlobShort(image);
262 break;
263 case VIPSBandFormatUINT:
264 case VIPSBandFormatINT:
265 s=(unsigned short) ReadBlobLong(image);
266 break;
267 case VIPSBandFormatFLOAT:
268 s=(unsigned short) ReadBlobFloat(image);
269 break;
270 case VIPSBandFormatDOUBLE:
271 s=(unsigned short) ReadBlobDouble(image);
272 break;
273 default:
274 s=0;
275 break;
276 }
277 return(ScaleShortToQuantum(s));
278 }
279 case VIPSTypeCMYK:
280 case VIPSTypesRGB:
281 switch(format)
282 {
283 case VIPSBandFormatUCHAR:
284 case VIPSBandFormatCHAR:
285 return(ScaleCharToQuantum((unsigned char) ReadBlobByte(image)));
286 case VIPSBandFormatUSHORT:
287 case VIPSBandFormatSHORT:
288 return(ScaleShortToQuantum(ReadBlobShort(image)));
289 case VIPSBandFormatUINT:
290 case VIPSBandFormatINT:
291 return(ScaleLongToQuantum(ReadBlobLong(image)));
292 case VIPSBandFormatFLOAT:
293 return((Quantum) ((float) QuantumRange*(ReadBlobFloat(image)/1.0)));
294 case VIPSBandFormatDOUBLE:
295 return((Quantum) ((double) QuantumRange*(ReadBlobDouble(
296 image)/1.0)));
297 default:
298 return((Quantum) 0);
299 }
300 default:
301 return((Quantum) 0);
302 }
303 }
304
ReadVIPSPixelsNONE(Image * image,const VIPSBandFormat format,const VIPSType type,const unsigned int channels,ExceptionInfo * exception)305 static MagickBooleanType ReadVIPSPixelsNONE(Image *image,
306 const VIPSBandFormat format,const VIPSType type,const unsigned int channels,
307 ExceptionInfo *exception)
308 {
309 Quantum
310 pixel;
311
312 Quantum
313 *q;
314
315 ssize_t
316 x;
317
318 ssize_t
319 y;
320
321 for (y = 0; y < (ssize_t) image->rows; y++)
322 {
323 q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
324 if (q == (Quantum *) NULL)
325 return MagickFalse;
326 for (x=0; x < (ssize_t) image->columns; x++)
327 {
328 pixel=ReadVIPSPixelNONE(image,format,type);
329 SetPixelRed(image,pixel,q);
330 if (channels < 3)
331 {
332 SetPixelGreen(image,pixel,q);
333 SetPixelBlue(image,pixel,q);
334 if (channels == 2)
335 SetPixelAlpha(image,ReadVIPSPixelNONE(image,format,type),q);
336 }
337 else
338 {
339 SetPixelGreen(image,ReadVIPSPixelNONE(image,format,type),q);
340 SetPixelBlue(image,ReadVIPSPixelNONE(image,format,type),q);
341 if (channels == 4)
342 {
343 if (image->colorspace == CMYKColorspace)
344 SetPixelIndex(image,ReadVIPSPixelNONE(image,format,type),q);
345 else
346 SetPixelAlpha(image,ReadVIPSPixelNONE(image,format,type),q);
347 }
348 else if (channels == 5)
349 {
350 SetPixelIndex(image,ReadVIPSPixelNONE(image,format,type),q);
351 SetPixelAlpha(image,ReadVIPSPixelNONE(image,format,type),q);
352 }
353 }
354 q+=GetPixelChannels(image);
355 }
356 if (SyncAuthenticPixels(image,exception) == MagickFalse)
357 return MagickFalse;
358 }
359 return(MagickTrue);
360 }
361
ReadVIPSImage(const ImageInfo * image_info,ExceptionInfo * exception)362 static Image *ReadVIPSImage(const ImageInfo *image_info,
363 ExceptionInfo *exception)
364 {
365 char
366 buffer[MagickPathExtent],
367 *metadata;
368
369 Image
370 *image;
371
372 MagickBooleanType
373 status;
374
375 ssize_t
376 n;
377
378 unsigned int
379 channels,
380 marker;
381
382 VIPSBandFormat
383 format;
384
385 VIPSCoding
386 coding;
387
388 VIPSType
389 type;
390
391 assert(image_info != (const ImageInfo *) NULL);
392 assert(image_info->signature == MagickCoreSignature);
393 if (image_info->debug != MagickFalse)
394 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
395 image_info->filename);
396 assert(exception != (ExceptionInfo *) NULL);
397 assert(exception->signature == MagickCoreSignature);
398
399 image=AcquireImage(image_info,exception);
400 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
401 if (status == MagickFalse)
402 {
403 image=DestroyImageList(image);
404 return((Image *) NULL);
405 }
406 marker=ReadBlobLSBLong(image);
407 if (marker == VIPS_MAGIC_LSB)
408 image->endian=LSBEndian;
409 else if (marker == VIPS_MAGIC_MSB)
410 image->endian=MSBEndian;
411 else
412 ThrowReaderException(CorruptImageError,"ImproperImageHeader");
413 image->columns=(size_t) ReadBlobLong(image);
414 image->rows=(size_t) ReadBlobLong(image);
415 status=SetImageExtent(image,image->columns,image->rows,exception);
416 if (status == MagickFalse)
417 return(DestroyImageList(image));
418 channels=ReadBlobLong(image);
419 (void) ReadBlobLong(image); /* Legacy */
420 format=(VIPSBandFormat) ReadBlobLong(image);
421 switch(format)
422 {
423 case VIPSBandFormatUCHAR:
424 case VIPSBandFormatCHAR:
425 image->depth=8;
426 break;
427 case VIPSBandFormatUSHORT:
428 case VIPSBandFormatSHORT:
429 image->depth=16;
430 break;
431 case VIPSBandFormatUINT:
432 case VIPSBandFormatINT:
433 case VIPSBandFormatFLOAT:
434 image->depth=32;
435 break;
436 case VIPSBandFormatDOUBLE:
437 image->depth=64;
438 break;
439 default:
440 case VIPSBandFormatCOMPLEX:
441 case VIPSBandFormatDPCOMPLEX:
442 case VIPSBandFormatNOTSET:
443 ThrowReaderException(CoderError,"Unsupported band format");
444 }
445 coding=(VIPSCoding) ReadBlobLong(image);
446 type=(VIPSType) ReadBlobLong(image);
447 switch(type)
448 {
449 case VIPSTypeCMYK:
450 SetImageColorspace(image,CMYKColorspace,exception);
451 if (channels == 5)
452 image->alpha_trait=BlendPixelTrait;
453 break;
454 case VIPSTypeB_W:
455 case VIPSTypeGREY16:
456 SetImageColorspace(image,GRAYColorspace,exception);
457 if (channels == 2)
458 image->alpha_trait=BlendPixelTrait;
459 break;
460 case VIPSTypeRGB:
461 case VIPSTypeRGB16:
462 SetImageColorspace(image,RGBColorspace,exception);
463 if (channels == 4)
464 image->alpha_trait=BlendPixelTrait;
465 break;
466 case VIPSTypesRGB:
467 SetImageColorspace(image,sRGBColorspace,exception);
468 if (channels == 4)
469 image->alpha_trait=BlendPixelTrait;
470 break;
471 default:
472 case VIPSTypeFOURIER:
473 case VIPSTypeHISTOGRAM:
474 case VIPSTypeLAB:
475 case VIPSTypeLABS:
476 case VIPSTypeLABQ:
477 case VIPSTypeLCH:
478 case VIPSTypeMULTIBAND:
479 case VIPSTypeUCS:
480 case VIPSTypeXYZ:
481 case VIPSTypeYXY:
482 ThrowReaderException(CoderError,"Unsupported colorspace");
483 }
484 (void) SetImageBackgroundColor(image,exception);
485 image->units=PixelsPerCentimeterResolution;
486 image->resolution.x=ReadBlobFloat(image)*10;
487 image->resolution.y=ReadBlobFloat(image)*10;
488 /*
489 Legacy, offsets, future
490 */
491 (void) ReadBlobLongLong(image);
492 (void) ReadBlobLongLong(image);
493 (void) ReadBlobLongLong(image);
494 if (image_info->ping != MagickFalse)
495 return(image);
496 if (IsSupportedCombination(format,type) == MagickFalse)
497 ThrowReaderException(CoderError,
498 "Unsupported combination of band format and colorspace");
499 if (channels == 0 || channels > 5)
500 ThrowReaderException(CoderError,"Unsupported number of channels");
501 if (coding == VIPSCodingNONE)
502 status=ReadVIPSPixelsNONE(image,format,type,channels,exception);
503 else
504 ThrowReaderException(CoderError,"Unsupported coding");
505 metadata=(char *) NULL;
506 while ((n=ReadBlob(image,MagickPathExtent-1,(unsigned char *) buffer)) != 0)
507 {
508 buffer[n]='\0';
509 if (metadata == (char *) NULL)
510 metadata=ConstantString(buffer);
511 else
512 (void) ConcatenateString(&metadata,buffer);
513 }
514 if (metadata != (char *) NULL)
515 {
516 SetImageProperty(image,"vips:metadata",metadata,exception);
517 metadata=(char *) RelinquishMagickMemory(metadata);
518 }
519 (void) CloseBlob(image);
520 if (status == MagickFalse)
521 return((Image *) NULL);
522 return(image);
523 }
524
525 /*
526 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
527 % %
528 % %
529 % %
530 % R e g i s t e r V I P S I m a g e %
531 % %
532 % %
533 % %
534 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
535 %
536 % RegisterVIPSmage() adds attributes for the VIPS image format to the list
537 % of supported formats. The attributes include the image format tag, a
538 % method to read and/or write the format, whether the format supports the
539 % saving of more than one frame to the same file or blob, whether the format
540 % supports native in-memory I/O, and a brief description of the format.
541 %
542 % The format of the RegisterVIPSImage method is:
543 %
544 % size_t RegisterVIPSImage(void)
545 %
546 */
RegisterVIPSImage(void)547 ModuleExport size_t RegisterVIPSImage(void)
548 {
549 MagickInfo
550 *entry;
551
552 entry=AcquireMagickInfo("VIPS","VIPS","VIPS image");
553 entry->decoder=(DecodeImageHandler *) ReadVIPSImage;
554 entry->encoder=(EncodeImageHandler *) WriteVIPSImage;
555 entry->magick=(IsImageFormatHandler *) IsVIPS;
556 entry->flags|=CoderEndianSupportFlag;
557 (void) RegisterMagickInfo(entry);
558 return(MagickImageCoderSignature);
559 }
560
561 /*
562 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
563 % %
564 % %
565 % %
566 % U n r e g i s t e r V I P S I m a g e %
567 % %
568 % %
569 % %
570 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
571 %
572 % UnregisterVIPSImage() removes format registrations made by the
573 % VIPS module from the list of supported formats.
574 %
575 % The format of the UnregisterVIPSImage method is:
576 %
577 % UnregisterVIPSImage(void)
578 %
579 */
UnregisterVIPSImage(void)580 ModuleExport void UnregisterVIPSImage(void)
581 {
582 (void) UnregisterMagickInfo("VIPS");
583 }
584
585 /*
586 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
587 % %
588 % %
589 % %
590 % W r i t e V I P S I m a g e %
591 % %
592 % %
593 % %
594 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
595 %
596 % WriteVIPSImage() writes an image to a file in VIPS image format.
597 %
598 % The format of the WriteVIPSImage method is:
599 %
600 % MagickBooleanType WriteVIPSImage(const ImageInfo *image_info,Image *image)
601 %
602 % A description of each parameter follows.
603 %
604 % o image_info: the image info.
605 %
606 % o image: The image.
607 %
608 */
609
WriteVIPSPixel(Image * image,const Quantum value)610 static inline void WriteVIPSPixel(Image *image, const Quantum value)
611 {
612 if (image->depth == 16)
613 (void) WriteBlobShort(image,ScaleQuantumToShort(value));
614 else
615 (void) WriteBlobByte(image,ScaleQuantumToChar(value));
616 }
617
WriteVIPSImage(const ImageInfo * image_info,Image * image,ExceptionInfo * exception)618 static MagickBooleanType WriteVIPSImage(const ImageInfo *image_info,
619 Image *image,ExceptionInfo *exception)
620 {
621 const char
622 *metadata;
623
624 MagickBooleanType
625 status;
626
627 const Quantum
628 *p;
629
630 ssize_t
631 x;
632
633 ssize_t
634 y;
635
636 unsigned int
637 channels;
638
639 assert(image_info != (const ImageInfo *) NULL);
640 assert(image_info->signature == MagickCoreSignature);
641 assert(image != (Image *) NULL);
642 assert(image->signature == MagickCoreSignature);
643 if (image->debug != MagickFalse)
644 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
645
646 status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
647 if (status == MagickFalse)
648 return(status);
649 if (image->endian == LSBEndian)
650 (void) WriteBlobLSBLong(image,VIPS_MAGIC_LSB);
651 else
652 (void) WriteBlobLSBLong(image,VIPS_MAGIC_MSB);
653 (void) WriteBlobLong(image,(unsigned int) image->columns);
654 (void) WriteBlobLong(image,(unsigned int) image->rows);
655 (void) SetImageStorageClass(image,DirectClass,exception);
656 channels=image->alpha_trait != UndefinedPixelTrait ? 4 : 3;
657 if (SetImageGray(image,exception) != MagickFalse)
658 channels=image->alpha_trait != UndefinedPixelTrait ? 2 : 1;
659 else if (image->colorspace == CMYKColorspace)
660 channels=image->alpha_trait != UndefinedPixelTrait ? 5 : 4;
661 (void) WriteBlobLong(image,channels);
662 (void) WriteBlobLong(image,0);
663 if (image->depth == 16)
664 (void) WriteBlobLong(image,(unsigned int) VIPSBandFormatUSHORT);
665 else
666 {
667 image->depth=8;
668 (void) WriteBlobLong(image,(unsigned int) VIPSBandFormatUCHAR);
669 }
670 (void) WriteBlobLong(image,VIPSCodingNONE);
671 switch(image->colorspace)
672 {
673 case CMYKColorspace:
674 (void) WriteBlobLong(image,VIPSTypeCMYK);
675 break;
676 case GRAYColorspace:
677 if (image->depth == 16)
678 (void) WriteBlobLong(image, VIPSTypeGREY16);
679 else
680 (void) WriteBlobLong(image, VIPSTypeB_W);
681 break;
682 case LabColorspace:
683 (void) WriteBlobLong(image,VIPSTypeLAB);
684 break;
685 case LCHColorspace:
686 (void) WriteBlobLong(image,VIPSTypeLCH);
687 break;
688 case RGBColorspace:
689 if (image->depth == 16)
690 (void) WriteBlobLong(image, VIPSTypeRGB16);
691 else
692 (void) WriteBlobLong(image, VIPSTypeRGB);
693 break;
694 case XYZColorspace:
695 (void) WriteBlobLong(image,VIPSTypeXYZ);
696 break;
697 default:
698 case sRGBColorspace:
699 (void) SetImageColorspace(image,sRGBColorspace,exception);
700 (void) WriteBlobLong(image,VIPSTypesRGB);
701 break;
702 }
703 if (image->units == PixelsPerCentimeterResolution)
704 {
705 (void) WriteBlobFloat(image,(image->resolution.x / 10));
706 (void) WriteBlobFloat(image,(image->resolution.y / 10));
707 }
708 else if (image->units == PixelsPerInchResolution)
709 {
710 (void) WriteBlobFloat(image,(image->resolution.x / 25.4));
711 (void) WriteBlobFloat(image,(image->resolution.y / 25.4));
712 }
713 else
714 {
715 (void) WriteBlobLong(image,0);
716 (void) WriteBlobLong(image,0);
717 }
718 /*
719 Legacy, Offsets, Future
720 */
721 for (y=0; y < 24; y++)
722 (void) WriteBlobByte(image,0);
723 for (y=0; y < (ssize_t) image->rows; y++)
724 {
725 p=GetVirtualPixels(image,0,y,image->columns,1,exception);
726 if (p == (const Quantum *) NULL)
727 break;
728 for (x=0; x < (ssize_t) image->columns; x++)
729 {
730 WriteVIPSPixel(image,GetPixelRed(image,p));
731 if (channels == 2)
732 WriteVIPSPixel(image,GetPixelAlpha(image,p));
733 else
734 {
735 WriteVIPSPixel(image,GetPixelGreen(image,p));
736 WriteVIPSPixel(image,GetPixelBlue(image,p));
737 if (channels >= 4)
738 {
739 if (image->colorspace == CMYKColorspace)
740 WriteVIPSPixel(image,GetPixelIndex(image,p));
741 else
742 WriteVIPSPixel(image,GetPixelAlpha(image,p));
743 }
744 else if (channels == 5)
745 {
746 WriteVIPSPixel(image,GetPixelIndex(image,p));
747 WriteVIPSPixel(image,GetPixelAlpha(image,p));
748 }
749 }
750 p+=GetPixelChannels(image);
751 }
752 }
753 metadata=GetImageProperty(image,"vips:metadata",exception);
754 if (metadata != (const char*) NULL)
755 WriteBlobString(image,metadata);
756 (void) CloseBlob(image);
757 return(status);
758 }
759