granicus.if.org Git - imagemagick/blob - coders/vips.c

   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-2014 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 \f
  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 *);\f
 118 \f
 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 */
 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
 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
 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
 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
 362 static Image *ReadVIPSImage(const ImageInfo *image_info,
 363   ExceptionInfo *exception)
 364 {
 365   char
 366     buffer[MaxTextExtent],
 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 == MagickSignature);
 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 == MagickSignature);
 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   channels=ReadBlobLong(image);
 416   (void) ReadBlobLong(image); /* Legacy */
 417   format=(VIPSBandFormat) ReadBlobLong(image);
 418   switch(format)
 419   {
 420     case VIPSBandFormatUCHAR:
 421     case VIPSBandFormatCHAR:
 422       image->depth=8;
 423       break;
 424     case VIPSBandFormatUSHORT:
 425     case VIPSBandFormatSHORT:
 426       image->depth=16;
 427       break;
 428     case VIPSBandFormatUINT:
 429     case VIPSBandFormatINT:
 430     case VIPSBandFormatFLOAT:
 431       image->depth=32;
 432       break;
 433     case VIPSBandFormatDOUBLE:
 434       image->depth=64;
 435       break;
 436     default:
 437     case VIPSBandFormatCOMPLEX:
 438     case VIPSBandFormatDPCOMPLEX:
 439     case VIPSBandFormatNOTSET:
 440       ThrowReaderException(CoderError,"Unsupported band format");
 441   }
 442   coding=(VIPSCoding) ReadBlobLong(image);
 443   type=(VIPSType) ReadBlobLong(image);
 444   switch(type)
 445   {
 446     case VIPSTypeCMYK:
 447       SetImageColorspace(image,CMYKColorspace,exception);
 448       if (channels == 5)
 449         image->alpha_trait=BlendPixelTrait;
 450       break;
 451     case VIPSTypeB_W:
 452     case VIPSTypeGREY16:
 453       SetImageColorspace(image,GRAYColorspace,exception);
 454       if (channels == 2)
 455         image->alpha_trait=BlendPixelTrait;
 456       break;
 457     case VIPSTypeRGB:
 458     case VIPSTypeRGB16:
 459       SetImageColorspace(image,RGBColorspace,exception);
 460       if (channels == 4)
 461         image->alpha_trait=BlendPixelTrait;
 462       break;
 463     case VIPSTypesRGB:
 464       SetImageColorspace(image,sRGBColorspace,exception);
 465       if (channels == 4)
 466         image->alpha_trait=BlendPixelTrait;
 467       break;
 468     default:
 469     case VIPSTypeFOURIER:
 470     case VIPSTypeHISTOGRAM:
 471     case VIPSTypeLAB:
 472     case VIPSTypeLABS:
 473     case VIPSTypeLABQ:
 474     case VIPSTypeLCH:
 475     case VIPSTypeMULTIBAND:
 476     case VIPSTypeUCS:
 477     case VIPSTypeXYZ:
 478     case VIPSTypeYXY:
 479       ThrowReaderException(CoderError,"Unsupported colorspace");
 480   }
 481   image->units=PixelsPerCentimeterResolution;
 482   image->resolution.x=ReadBlobFloat(image)*10;
 483   image->resolution.y=ReadBlobFloat(image)*10;
 484   /*
 485     Legacy, offsets, future
 486   */
 487   (void) ReadBlobLongLong(image);
 488   (void) ReadBlobLongLong(image);
 489   (void) ReadBlobLongLong(image);
 490   if (image_info->ping != MagickFalse)
 491     return(image);
 492   if (IsSupportedCombination(format,type) == MagickFalse)
 493     ThrowReaderException(CoderError,
 494       "Unsupported combination of band format and colorspace");
 495   if (channels == 0 || channels > 5)
 496     ThrowReaderException(CoderError,"Unsupported number of channels");
 497   if (coding == VIPSCodingNONE)
 498     status=ReadVIPSPixelsNONE(image,format,type,channels,exception);
 499   else
 500     ThrowReaderException(CoderError,"Unsupported coding");
 501   metadata=(char *) NULL;
 502   while ((n=ReadBlob(image,MaxTextExtent-1,(unsigned char *) buffer)) != 0)
 503   {
 504     buffer[n]='\0';
 505     if (metadata == (char *) NULL)
 506       metadata=ConstantString(buffer);
 507     else
 508       (void) ConcatenateString(&metadata,buffer);
 509   }
 510   if (metadata != (char *) NULL)
 511     SetImageProperty(image,"vips:metadata",metadata,exception);
 512   (void) CloseBlob(image);
 513   if (status == MagickFalse)
 514     return((Image *) NULL);
 515   return(image);
 516 }
 517 \f
 518 /*
 519 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 520 %                                                                             %
 521 %                                                                             %
 522 %                                                                             %
 523 %   R e g i s t e r V I P S I m a g e                                         %
 524 %                                                                             %
 525 %                                                                             %
 526 %                                                                             %
 527 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 528 %
 529 %  RegisterVIPSmage() adds attributes for the VIPS image format to the list
 530 %  of supported formats.  The attributes include the image format tag, a
 531 %  method to read and/or write the format, whether the format supports the
 532 %  saving of more than one frame to the same file or blob, whether the format
 533 %  supports native in-memory I/O, and a brief description of the format.
 534 %
 535 %  The format of the RegisterVIPSImage method is:
 536 %
 537 %      size_t RegisterVIPSImage(void)
 538 %
 539 */
 540 ModuleExport size_t RegisterVIPSImage(void)
 541 {
 542   MagickInfo
 543     *entry;
 544
 545   entry=SetMagickInfo("VIPS");
 546   entry->decoder=(DecodeImageHandler *) ReadVIPSImage;
 547   entry->encoder=(EncodeImageHandler *) WriteVIPSImage;
 548   entry->magick=(IsImageFormatHandler *) IsVIPS;
 549   entry->description=ConstantString("VIPS image");
 550   entry->endian_support=MagickTrue;
 551   entry->module=ConstantString("VIPS");
 552   (void) RegisterMagickInfo(entry);
 553   return(MagickImageCoderSignature);
 554 }
 555 \f
 556 /*
 557 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 558 %                                                                             %
 559 %                                                                             %
 560 %                                                                             %
 561 %   U n r e g i s t e r V I P S I m a g e                                     %
 562 %                                                                             %
 563 %                                                                             %
 564 %                                                                             %
 565 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 566 %
 567 %  UnregisterVIPSImage() removes format registrations made by the
 568 %  VIPS module from the list of supported formats.
 569 %
 570 %  The format of the UnregisterVIPSImage method is:
 571 %
 572 %      UnregisterVIPSImage(void)
 573 %
 574 */
 575 ModuleExport void UnregisterVIPSImage(void)
 576 {
 577   (void) UnregisterMagickInfo("VIPS");
 578 }
 579 \f
 580 /*
 581 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 582 %                                                                             %
 583 %                                                                             %
 584 %                                                                             %
 585 %   W r i t e V I P S I m a g e                                               %
 586 %                                                                             %
 587 %                                                                             %
 588 %                                                                             %
 589 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 590 %
 591 %  WriteVIPSImage() writes an image to a file in VIPS image format.
 592 %
 593 %  The format of the WriteVIPSImage method is:
 594 %
 595 %      MagickBooleanType WriteVIPSImage(const ImageInfo *image_info,Image *image)
 596 %
 597 %  A description of each parameter follows.
 598 %
 599 %    o image_info: the image info.
 600 %
 601 %    o image:  The image.
 602 %
 603 */
 604
 605 static inline void WriteVIPSPixel(Image *image, const Quantum value)
 606 {
 607   if (image->depth == 16)
 608     (void) WriteBlobShort(image,ScaleQuantumToShort(value));
 609   else
 610     (void) WriteBlobByte(image,ScaleQuantumToChar(value));
 611 }
 612
 613 static MagickBooleanType WriteVIPSImage(const ImageInfo *image_info,
 614   Image *image,ExceptionInfo *exception)
 615 {
 616   const char
 617     *metadata;
 618
 619   MagickBooleanType
 620     status;
 621
 622   register const Quantum
 623     *p;
 624
 625   register ssize_t
 626     x;
 627
 628   ssize_t
 629     y;
 630
 631   unsigned int
 632     channels;
 633
 634   assert(image_info != (const ImageInfo *) NULL);
 635   assert(image_info->signature == MagickSignature);
 636   assert(image != (Image *) NULL);
 637   assert(image->signature == MagickSignature);
 638   if (image->debug != MagickFalse)
 639     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 640
 641   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
 642   if (status == MagickFalse)
 643     return(status);
 644   if (image->endian == LSBEndian)
 645     (void) WriteBlobLSBLong(image,VIPS_MAGIC_LSB);
 646   else
 647     (void) WriteBlobLSBLong(image,VIPS_MAGIC_MSB);
 648   (void) WriteBlobLong(image,(unsigned int) image->columns);
 649   (void) WriteBlobLong(image,(unsigned int) image->rows);
 650   (void) SetImageStorageClass(image,DirectClass,exception);
 651   channels=image->alpha_trait == BlendPixelTrait ? 4 : 3;
 652   if (IsImageGray(image,exception) != MagickFalse)
 653     channels=image->alpha_trait == BlendPixelTrait ? 2 : 1;
 654   else if (image->colorspace == CMYKColorspace)
 655     channels=image->alpha_trait == BlendPixelTrait ? 5 : 4;
 656   (void) WriteBlobLong(image,channels);
 657   (void) WriteBlobLong(image,0);
 658   if (image->depth == 16)
 659     (void) WriteBlobLong(image,(unsigned int) VIPSBandFormatUSHORT);
 660   else
 661     {
 662       image->depth=8;
 663       (void) WriteBlobLong(image,(unsigned int) VIPSBandFormatUCHAR);
 664     }
 665   (void) WriteBlobLong(image,VIPSCodingNONE);
 666   switch(image->colorspace)
 667   {
 668     case CMYKColorspace:
 669       (void) WriteBlobLong(image,VIPSTypeCMYK);
 670       break;
 671     case GRAYColorspace:
 672       if (image->depth == 16)
 673         (void) WriteBlobLong(image, VIPSTypeGREY16);
 674       else
 675         (void) WriteBlobLong(image, VIPSTypeB_W);
 676       break;
 677     case LabColorspace:
 678       (void) WriteBlobLong(image,VIPSTypeLAB);
 679       break;
 680     case LCHColorspace:
 681       (void) WriteBlobLong(image,VIPSTypeLCH);
 682       break;
 683     case RGBColorspace:
 684       if (image->depth == 16)
 685         (void) WriteBlobLong(image, VIPSTypeRGB16);
 686       else
 687         (void) WriteBlobLong(image, VIPSTypeRGB);
 688       break;
 689     case XYZColorspace:
 690       (void) WriteBlobLong(image,VIPSTypeXYZ);
 691       break;
 692     default:
 693     case sRGBColorspace:
 694       (void) SetImageColorspace(image,sRGBColorspace,exception);
 695       (void) WriteBlobLong(image,VIPSTypesRGB);
 696       break;
 697   }
 698   if (image->units == PixelsPerCentimeterResolution)
 699     {
 700       (void) WriteBlobFloat(image,(image->resolution.x / 10));
 701       (void) WriteBlobFloat(image,(image->resolution.y / 10));
 702     }
 703   else if (image->units == PixelsPerInchResolution)
 704     {
 705       (void) WriteBlobFloat(image,(image->resolution.x / 25.4));
 706       (void) WriteBlobFloat(image,(image->resolution.y / 25.4));
 707     }
 708   else
 709     {
 710       (void) WriteBlobLong(image,0);
 711       (void) WriteBlobLong(image,0);
 712     }
 713   /*
 714     Legacy, Offsets, Future
 715   */
 716   for (y=0; y < 24; y++)
 717     (void) WriteBlobByte(image,0);
 718   for (y=0; y < (ssize_t) image->rows; y++)
 719   {
 720     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 721     if (p == (const Quantum *) NULL)
 722       break;
 723     for (x=0; x < (ssize_t) image->columns; x++)
 724     {
 725       WriteVIPSPixel(image,GetPixelRed(image,p));
 726       if (channels == 2)
 727         WriteVIPSPixel(image,GetPixelAlpha(image,p));
 728       else
 729         {
 730           WriteVIPSPixel(image,GetPixelGreen(image,p));
 731           WriteVIPSPixel(image,GetPixelBlue(image,p));
 732           if (channels >= 4)
 733             {
 734               if (image->colorspace == CMYKColorspace)
 735                 WriteVIPSPixel(image,GetPixelIndex(image,p));
 736               else
 737                 WriteVIPSPixel(image,GetPixelAlpha(image,p));
 738             }
 739           else if (channels == 5)
 740             {
 741                WriteVIPSPixel(image,GetPixelIndex(image,p));
 742                WriteVIPSPixel(image,GetPixelAlpha(image,p));
 743             }
 744         }
 745       p+=GetPixelChannels(image);
 746     }
 747   }
 748   metadata=GetImageProperty(image,"vips:metadata",exception);
 749   if (metadata != (const char*) NULL)
 750     WriteBlobString(image,metadata);
 751   (void) CloseBlob(image);
 752   return(status);
 753 }