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-2016 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 % http://www.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 colour space */
100 VIPSTypeLAB = 13, /* CIE LAB colour 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) colour space */
105 VIPSTypeLCH = 19, /* CIE LCh colour space */
106 VIPSTypeLABS = 21, /* 48-bit CIE LAB */
107 VIPSTypesRGB = 22, /* sRGB colour space */
108 VIPSTypeYXY = 23, /* CIE Yxy colour 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 register Quantum
313 *q;
314
315 register 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 image->units=PixelsPerCentimeterResolution;
485 image->resolution.x=ReadBlobFloat(image)*10;
486 image->resolution.y=ReadBlobFloat(image)*10;
487 /*
488 Legacy, offsets, future
489 */
490 (void) ReadBlobLongLong(image);
491 (void) ReadBlobLongLong(image);
492 (void) ReadBlobLongLong(image);
493 if (image_info->ping != MagickFalse)
494 return(image);
495 if (IsSupportedCombination(format,type) == MagickFalse)
496 ThrowReaderException(CoderError,
497 "Unsupported combination of band format and colorspace");
498 if (channels == 0 || channels > 5)
499 ThrowReaderException(CoderError,"Unsupported number of channels");
500 if (coding == VIPSCodingNONE)
501 status=ReadVIPSPixelsNONE(image,format,type,channels,exception);
502 else
503 ThrowReaderException(CoderError,"Unsupported coding");
504 metadata=(char *) NULL;
505 while ((n=ReadBlob(image,MagickPathExtent-1,(unsigned char *) buffer)) != 0)
506 {
507 buffer[n]='\0';
508 if (metadata == (char *) NULL)
509 metadata=ConstantString(buffer);
510 else
511 (void) ConcatenateString(&metadata,buffer);
512 }
513 if (metadata != (char *) NULL)
514 SetImageProperty(image,"vips:metadata",metadata,exception);
515 (void) CloseBlob(image);
516 if (status == MagickFalse)
517 return((Image *) NULL);
518 return(image);
519 }
520
521 /*
522 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
523 % %
524 % %
525 % %
526 % R e g i s t e r V I P S I m a g e %
527 % %
528 % %
529 % %
530 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
531 %
532 % RegisterVIPSmage() adds attributes for the VIPS image format to the list
533 % of supported formats. The attributes include the image format tag, a
534 % method to read and/or write the format, whether the format supports the
535 % saving of more than one frame to the same file or blob, whether the format
536 % supports native in-memory I/O, and a brief description of the format.
537 %
538 % The format of the RegisterVIPSImage method is:
539 %
540 % size_t RegisterVIPSImage(void)
541 %
542 */
RegisterVIPSImage(void)543 ModuleExport size_t RegisterVIPSImage(void)
544 {
545 MagickInfo
546 *entry;
547
548 entry=AcquireMagickInfo("VIPS","VIPS","VIPS image");
549 entry->decoder=(DecodeImageHandler *) ReadVIPSImage;
550 entry->encoder=(EncodeImageHandler *) WriteVIPSImage;
551 entry->magick=(IsImageFormatHandler *) IsVIPS;
552 entry->flags|=CoderEndianSupportFlag;
553 (void) RegisterMagickInfo(entry);
554 return(MagickImageCoderSignature);
555 }
556
557 /*
558 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
559 % %
560 % %
561 % %
562 % U n r e g i s t e r V I P S I m a g e %
563 % %
564 % %
565 % %
566 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
567 %
568 % UnregisterVIPSImage() removes format registrations made by the
569 % VIPS module from the list of supported formats.
570 %
571 % The format of the UnregisterVIPSImage method is:
572 %
573 % UnregisterVIPSImage(void)
574 %
575 */
UnregisterVIPSImage(void)576 ModuleExport void UnregisterVIPSImage(void)
577 {
578 (void) UnregisterMagickInfo("VIPS");
579 }
580
581 /*
582 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
583 % %
584 % %
585 % %
586 % W r i t e V I P S I m a g e %
587 % %
588 % %
589 % %
590 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
591 %
592 % WriteVIPSImage() writes an image to a file in VIPS image format.
593 %
594 % The format of the WriteVIPSImage method is:
595 %
596 % MagickBooleanType WriteVIPSImage(const ImageInfo *image_info,Image *image)
597 %
598 % A description of each parameter follows.
599 %
600 % o image_info: the image info.
601 %
602 % o image: The image.
603 %
604 */
605
WriteVIPSPixel(Image * image,const Quantum value)606 static inline void WriteVIPSPixel(Image *image, const Quantum value)
607 {
608 if (image->depth == 16)
609 (void) WriteBlobShort(image,ScaleQuantumToShort(value));
610 else
611 (void) WriteBlobByte(image,ScaleQuantumToChar(value));
612 }
613
WriteVIPSImage(const ImageInfo * image_info,Image * image,ExceptionInfo * exception)614 static MagickBooleanType WriteVIPSImage(const ImageInfo *image_info,
615 Image *image,ExceptionInfo *exception)
616 {
617 const char
618 *metadata;
619
620 MagickBooleanType
621 status;
622
623 register const Quantum
624 *p;
625
626 register ssize_t
627 x;
628
629 ssize_t
630 y;
631
632 unsigned int
633 channels;
634
635 assert(image_info != (const ImageInfo *) NULL);
636 assert(image_info->signature == MagickCoreSignature);
637 assert(image != (Image *) NULL);
638 assert(image->signature == MagickCoreSignature);
639 if (image->debug != MagickFalse)
640 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
641
642 status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
643 if (status == MagickFalse)
644 return(status);
645 if (image->endian == LSBEndian)
646 (void) WriteBlobLSBLong(image,VIPS_MAGIC_LSB);
647 else
648 (void) WriteBlobLSBLong(image,VIPS_MAGIC_MSB);
649 (void) WriteBlobLong(image,(unsigned int) image->columns);
650 (void) WriteBlobLong(image,(unsigned int) image->rows);
651 (void) SetImageStorageClass(image,DirectClass,exception);
652 channels=image->alpha_trait != UndefinedPixelTrait ? 4 : 3;
653 if (SetImageGray(image,exception) != MagickFalse)
654 channels=image->alpha_trait != UndefinedPixelTrait ? 2 : 1;
655 else if (image->colorspace == CMYKColorspace)
656 channels=image->alpha_trait != UndefinedPixelTrait ? 5 : 4;
657 (void) WriteBlobLong(image,channels);
658 (void) WriteBlobLong(image,0);
659 if (image->depth == 16)
660 (void) WriteBlobLong(image,(unsigned int) VIPSBandFormatUSHORT);
661 else
662 {
663 image->depth=8;
664 (void) WriteBlobLong(image,(unsigned int) VIPSBandFormatUCHAR);
665 }
666 (void) WriteBlobLong(image,VIPSCodingNONE);
667 switch(image->colorspace)
668 {
669 case CMYKColorspace:
670 (void) WriteBlobLong(image,VIPSTypeCMYK);
671 break;
672 case GRAYColorspace:
673 if (image->depth == 16)
674 (void) WriteBlobLong(image, VIPSTypeGREY16);
675 else
676 (void) WriteBlobLong(image, VIPSTypeB_W);
677 break;
678 case LabColorspace:
679 (void) WriteBlobLong(image,VIPSTypeLAB);
680 break;
681 case LCHColorspace:
682 (void) WriteBlobLong(image,VIPSTypeLCH);
683 break;
684 case RGBColorspace:
685 if (image->depth == 16)
686 (void) WriteBlobLong(image, VIPSTypeRGB16);
687 else
688 (void) WriteBlobLong(image, VIPSTypeRGB);
689 break;
690 case XYZColorspace:
691 (void) WriteBlobLong(image,VIPSTypeXYZ);
692 break;
693 default:
694 case sRGBColorspace:
695 (void) SetImageColorspace(image,sRGBColorspace,exception);
696 (void) WriteBlobLong(image,VIPSTypesRGB);
697 break;
698 }
699 if (image->units == PixelsPerCentimeterResolution)
700 {
701 (void) WriteBlobFloat(image,(image->resolution.x / 10));
702 (void) WriteBlobFloat(image,(image->resolution.y / 10));
703 }
704 else if (image->units == PixelsPerInchResolution)
705 {
706 (void) WriteBlobFloat(image,(image->resolution.x / 25.4));
707 (void) WriteBlobFloat(image,(image->resolution.y / 25.4));
708 }
709 else
710 {
711 (void) WriteBlobLong(image,0);
712 (void) WriteBlobLong(image,0);
713 }
714 /*
715 Legacy, Offsets, Future
716 */
717 for (y=0; y < 24; y++)
718 (void) WriteBlobByte(image,0);
719 for (y=0; y < (ssize_t) image->rows; y++)
720 {
721 p=GetVirtualPixels(image,0,y,image->columns,1,exception);
722 if (p == (const Quantum *) NULL)
723 break;
724 for (x=0; x < (ssize_t) image->columns; x++)
725 {
726 WriteVIPSPixel(image,GetPixelRed(image,p));
727 if (channels == 2)
728 WriteVIPSPixel(image,GetPixelAlpha(image,p));
729 else
730 {
731 WriteVIPSPixel(image,GetPixelGreen(image,p));
732 WriteVIPSPixel(image,GetPixelBlue(image,p));
733 if (channels >= 4)
734 {
735 if (image->colorspace == CMYKColorspace)
736 WriteVIPSPixel(image,GetPixelIndex(image,p));
737 else
738 WriteVIPSPixel(image,GetPixelAlpha(image,p));
739 }
740 else if (channels == 5)
741 {
742 WriteVIPSPixel(image,GetPixelIndex(image,p));
743 WriteVIPSPixel(image,GetPixelAlpha(image,p));
744 }
745 }
746 p+=GetPixelChannels(image);
747 }
748 }
749 metadata=GetImageProperty(image,"vips:metadata",exception);
750 if (metadata != (const char*) NULL)
751 WriteBlobString(image,metadata);
752 (void) CloseBlob(image);
753 return(status);
754 }
755