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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            SSSSS  U   U  N   N                              %
   7 %                            SS     U   U  NN  N                              %
   8 %                             SSS   U   U  N N N                              %
   9 %                               SS  U   U  N  NN                              %
  10 %                            SSSSS   UUU   N   N                              %
  11 %                                                                             %
  12 %                                                                             %
  13 %                    Read/Write Sun Rasterfile Image Format                   %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2011 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/color.h"
  48 #include "MagickCore/color-private.h"
  49 #include "MagickCore/colormap.h"
  50 #include "MagickCore/colorspace.h"
  51 #include "MagickCore/colorspace-private.h"
  52 #include "MagickCore/exception.h"
  53 #include "MagickCore/exception-private.h"
  54 #include "MagickCore/image.h"
  55 #include "MagickCore/image-private.h"
  56 #include "MagickCore/list.h"
  57 #include "MagickCore/magick.h"
  58 #include "MagickCore/memory_.h"
  59 #include "MagickCore/monitor.h"
  60 #include "MagickCore/monitor-private.h"
  61 #include "MagickCore/pixel-accessor.h"
  62 #include "MagickCore/quantum-private.h"
  63 #include "MagickCore/static.h"
  64 #include "MagickCore/string_.h"
  65 #include "MagickCore/module.h"
  66 \f
  67 /*
  68   Forward declarations.
  69 */
  70 static MagickBooleanType
  71   WriteSUNImage(const ImageInfo *,Image *);
  72 \f
  73 /*
  74 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  75 %                                                                             %
  76 %                                                                             %
  77 %                                                                             %
  78 %   I s S U N                                                                 %
  79 %                                                                             %
  80 %                                                                             %
  81 %                                                                             %
  82 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  83 %
  84 %  IsSUN() returns MagickTrue if the image format type, identified by the
  85 %  magick string, is SUN.
  86 %
  87 %  The format of the IsSUN method is:
  88 %
  89 %      MagickBooleanType IsSUN(const unsigned char *magick,const size_t length)
  90 %
  91 %  A description of each parameter follows:
  92 %
  93 %    o magick: compare image format pattern against these bytes.
  94 %
  95 %    o length: Specifies the length of the magick string.
  96 %
  97 */
  98 static MagickBooleanType IsSUN(const unsigned char *magick,const size_t length)
  99 {
 100   if (length < 4)
 101     return(MagickFalse);
 102   if (memcmp(magick,"\131\246\152\225",4) == 0)
 103     return(MagickTrue);
 104   return(MagickFalse);
 105 }
 106 \f
 107 /*
 108 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 109 %                                                                             %
 110 %                                                                             %
 111 %                                                                             %
 112 %   D e c o d e I m a g e                                                     %
 113 %                                                                             %
 114 %                                                                             %
 115 %                                                                             %
 116 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 117 %
 118 %  DecodeImage unpacks the packed image pixels into  runlength-encoded pixel
 119 %  packets.
 120 %
 121 %  The format of the DecodeImage method is:
 122 %
 123 %      MagickBooleanType DecodeImage(const unsigned char *compressed_pixels,
 124 %        const size_t length,unsigned char *pixels)
 125 %
 126 %  A description of each parameter follows:
 127 %
 128 %    o compressed_pixels:  The address of a byte (8 bits) array of compressed
 129 %      pixel data.
 130 %
 131 %    o length:  An integer value that is the total number of bytes of the
 132 %      source image (as just read by ReadBlob)
 133 %
 134 %    o pixels:  The address of a byte (8 bits) array of pixel data created by
 135 %      the uncompression process.  The number of bytes in this array
 136 %      must be at least equal to the number columns times the number of rows
 137 %      of the source pixels.
 138 %
 139 */
 140 static MagickBooleanType DecodeImage(const unsigned char *compressed_pixels,
 141   const size_t length,unsigned char *pixels,size_t maxpixels)
 142 {
 143   register const unsigned char
 144     *l,
 145     *p;
 146
 147   register unsigned char
 148     *q;
 149
 150   ssize_t
 151     count;
 152
 153   unsigned char
 154     byte;
 155
 156   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 157   assert(compressed_pixels != (unsigned char *) NULL);
 158   assert(pixels != (unsigned char *) NULL);
 159   p=compressed_pixels;
 160   q=pixels;
 161   l=q+maxpixels;
 162   while (((size_t) (p-compressed_pixels) < length) && (q < l))
 163   {
 164     byte=(*p++);
 165     if (byte != 128U)
 166       *q++=byte;
 167     else
 168       {
 169         /*
 170           Runlength-encoded packet: <count><byte>
 171         */
 172         count=(ssize_t) (*p++);
 173         if (count > 0)
 174           byte=(*p++);
 175         while ((count >= 0) && (q < l))
 176         {
 177           *q++=byte;
 178           count--;
 179         }
 180      }
 181   }
 182   return(MagickTrue);
 183 }
 184 \f
 185 /*
 186 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 187 %                                                                             %
 188 %                                                                             %
 189 %                                                                             %
 190 %   R e a d S U N I m a g e                                                   %
 191 %                                                                             %
 192 %                                                                             %
 193 %                                                                             %
 194 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 195 %
 196 %  ReadSUNImage() reads a SUN image file and returns it.  It allocates
 197 %  the memory necessary for the new Image structure and returns a pointer to
 198 %  the new image.
 199 %
 200 %  The format of the ReadSUNImage method is:
 201 %
 202 %      Image *ReadSUNImage(const ImageInfo *image_info,ExceptionInfo *exception)
 203 %
 204 %  A description of each parameter follows:
 205 %
 206 %    o image_info: the image info.
 207 %
 208 %    o exception: return any errors or warnings in this structure.
 209 %
 210 */
 211 static Image *ReadSUNImage(const ImageInfo *image_info,ExceptionInfo *exception)
 212 {
 213 #define RMT_EQUAL_RGB  1
 214 #define RMT_NONE  0
 215 #define RMT_RAW  2
 216 #define RT_STANDARD  1
 217 #define RT_ENCODED  2
 218 #define RT_FORMAT_RGB  3
 219
 220   typedef struct _SUNInfo
 221   {
 222     unsigned int
 223       magic,
 224       width,
 225       height,
 226       depth,
 227       length,
 228       type,
 229       maptype,
 230       maplength;
 231   } SUNInfo;
 232
 233   Image
 234     *image;
 235
 236   int
 237     bit;
 238
 239   MagickBooleanType
 240     status;
 241
 242   MagickSizeType
 243     number_pixels;
 244
 245   register Quantum
 246     *q;
 247
 248   register ssize_t
 249     i,
 250     x;
 251
 252   register unsigned char
 253     *p;
 254
 255   size_t
 256     length;
 257
 258   ssize_t
 259     count,
 260     y;
 261
 262   SUNInfo
 263     sun_info;
 264
 265   unsigned char
 266     *sun_data,
 267     *sun_pixels;
 268
 269   unsigned int
 270     bytes_per_line;
 271
 272   /*
 273     Open image file.
 274   */
 275   assert(image_info != (const ImageInfo *) NULL);
 276   assert(image_info->signature == MagickSignature);
 277   if (image_info->debug != MagickFalse)
 278     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 279       image_info->filename);
 280   assert(exception != (ExceptionInfo *) NULL);
 281   assert(exception->signature == MagickSignature);
 282   image=AcquireImage(image_info);
 283   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 284   if (status == MagickFalse)
 285     {
 286       image=DestroyImageList(image);
 287       return((Image *) NULL);
 288     }
 289   /*
 290     Read SUN raster header.
 291   */
 292   (void) ResetMagickMemory(&sun_info,0,sizeof(sun_info));
 293   sun_info.magic=ReadBlobMSBLong(image);
 294   do
 295   {
 296     /*
 297       Verify SUN identifier.
 298     */
 299     if (sun_info.magic != 0x59a66a95)
 300       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 301     sun_info.width=ReadBlobMSBLong(image);
 302     sun_info.height=ReadBlobMSBLong(image);
 303     sun_info.depth=ReadBlobMSBLong(image);
 304     sun_info.length=ReadBlobMSBLong(image);
 305     sun_info.type=ReadBlobMSBLong(image);
 306     sun_info.maptype=ReadBlobMSBLong(image);
 307     sun_info.maplength=ReadBlobMSBLong(image);
 308     image->columns=sun_info.width;
 309     image->rows=sun_info.height;
 310     if ((sun_info.depth == 0) || (sun_info.depth > 32))
 311       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 312     image->depth=sun_info.depth <= 8 ? sun_info.depth :
 313       MAGICKCORE_QUANTUM_DEPTH;
 314     if (sun_info.depth < 24)
 315       {
 316         size_t
 317           one;
 318
 319         image->storage_class=PseudoClass;
 320         image->colors=sun_info.maplength;
 321         one=1;
 322         if (sun_info.maptype == RMT_NONE)
 323           image->colors=one << sun_info.depth;
 324         if (sun_info.maptype == RMT_EQUAL_RGB)
 325           image->colors=sun_info.maplength/3;
 326       }
 327     switch (sun_info.maptype)
 328     {
 329       case RMT_NONE:
 330       {
 331         if (sun_info.depth < 24)
 332           {
 333             /*
 334               Create linear color ramp.
 335             */
 336             if (AcquireImageColormap(image,image->colors) == MagickFalse)
 337               ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 338           }
 339         break;
 340       }
 341       case RMT_EQUAL_RGB:
 342       {
 343         unsigned char
 344           *sun_colormap;
 345
 346         /*
 347           Read SUN raster colormap.
 348         */
 349         if (AcquireImageColormap(image,image->colors) == MagickFalse)
 350           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 351         sun_colormap=(unsigned char *) AcquireQuantumMemory(image->colors,
 352           sizeof(*sun_colormap));
 353         if (sun_colormap == (unsigned char *) NULL)
 354           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 355         count=ReadBlob(image,image->colors,sun_colormap);
 356         for (i=0; i < (ssize_t) image->colors; i++)
 357           image->colormap[i].red=ScaleCharToQuantum(sun_colormap[i]);
 358         count=ReadBlob(image,image->colors,sun_colormap);
 359         for (i=0; i < (ssize_t) image->colors; i++)
 360           image->colormap[i].green=ScaleCharToQuantum(sun_colormap[i]);
 361         count=ReadBlob(image,image->colors,sun_colormap);
 362         for (i=0; i < (ssize_t) image->colors; i++)
 363           image->colormap[i].blue=ScaleCharToQuantum(sun_colormap[i]);
 364         sun_colormap=(unsigned char *) RelinquishMagickMemory(sun_colormap);
 365         break;
 366       }
 367       case RMT_RAW:
 368       {
 369         unsigned char
 370           *sun_colormap;
 371
 372         /*
 373           Read SUN raster colormap.
 374         */
 375         sun_colormap=(unsigned char *) AcquireQuantumMemory(sun_info.maplength,
 376           sizeof(*sun_colormap));
 377         if (sun_colormap == (unsigned char *) NULL)
 378           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 379         count=ReadBlob(image,sun_info.maplength,sun_colormap);
 380         sun_colormap=(unsigned char *) RelinquishMagickMemory(sun_colormap);
 381         break;
 382       }
 383       default:
 384         ThrowReaderException(CoderError,"ColormapTypeNotSupported");
 385     }
 386     image->matte=sun_info.depth == 32 ? MagickTrue : MagickFalse;
 387     image->columns=sun_info.width;
 388     image->rows=sun_info.height;
 389     if (image_info->ping != MagickFalse)
 390       {
 391         (void) CloseBlob(image);
 392         return(GetFirstImageInList(image));
 393       }
 394     if ((sun_info.length*sizeof(*sun_data))/sizeof(*sun_data) !=
 395         sun_info.length || !sun_info.length)
 396       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 397     number_pixels=(MagickSizeType) image->columns*image->rows;
 398     if ((sun_info.depth >= 8) &&
 399         ((number_pixels*((sun_info.depth+7)/8)) > sun_info.length))
 400       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 401     sun_data=(unsigned char *) AcquireQuantumMemory((size_t) sun_info.length,
 402       sizeof(*sun_data));
 403     if (sun_data == (unsigned char *) NULL)
 404       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 405     count=(ssize_t) ReadBlob(image,sun_info.length,sun_data);
 406     if ((count == 0) && (sun_info.type != RT_ENCODED))
 407       ThrowReaderException(CorruptImageError,"UnableToReadImageData");
 408     sun_pixels=sun_data;
 409     bytes_per_line=0;
 410     if (sun_info.type == RT_ENCODED)
 411       {
 412         size_t
 413           height;
 414
 415         /*
 416           Read run-length encoded raster pixels.
 417         */
 418         height=sun_info.height;
 419         bytes_per_line=sun_info.width*sun_info.depth;
 420         if ((height == 0) || (sun_info.width == 0) || (sun_info.depth == 0) ||
 421             ((bytes_per_line/sun_info.depth) != sun_info.width))
 422           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 423         bytes_per_line+=15;
 424         bytes_per_line<<=1;
 425         if ((bytes_per_line >> 1) != (sun_info.width*sun_info.depth+15))
 426           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 427         bytes_per_line>>=4;
 428         sun_pixels=(unsigned char *) AcquireQuantumMemory(height,
 429           bytes_per_line*sizeof(*sun_pixels));
 430         if (sun_pixels == (unsigned char *) NULL)
 431           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 432         (void) DecodeImage(sun_data,sun_info.length,sun_pixels,
 433           bytes_per_line*height);
 434         sun_data=(unsigned char *) RelinquishMagickMemory(sun_data);
 435       }
 436     /*
 437       Convert SUN raster image to pixel packets.
 438     */
 439     p=sun_pixels;
 440     if (sun_info.depth == 1)
 441       for (y=0; y < (ssize_t) image->rows; y++)
 442       {
 443         q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 444         if (q == (const Quantum *) NULL)
 445           break;
 446         for (x=0; x < ((ssize_t) image->columns-7); x+=8)
 447         {
 448           for (bit=7; bit >= 0; bit--)
 449           {
 450             SetPixelIndex(image,((*p) & (0x01 << bit) ? 0x00 : 0x01),q);
 451             q+=GetPixelChannels(image);
 452           }
 453           p++;
 454         }
 455         if ((image->columns % 8) != 0)
 456           {
 457             for (bit=7; bit >= (ssize_t) (8-(image->columns % 8)); bit--)
 458             {
 459               SetPixelIndex(image,(*p) & (0x01 << bit) ? 0x00 : 0x01,q);
 460               q+=GetPixelChannels(image);
 461             }
 462             p++;
 463           }
 464         if ((((image->columns/8)+(image->columns % 8 ? 1 : 0)) % 2) != 0)
 465           p++;
 466         if (SyncAuthenticPixels(image,exception) == MagickFalse)
 467           break;
 468         if (image->previous == (Image *) NULL)
 469           {
 470             status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 471               image->rows);
 472             if (status == MagickFalse)
 473               break;
 474           }
 475       }
 476     else
 477       if (image->storage_class == PseudoClass)
 478         {
 479           length=image->rows*(image->columns+image->columns % 2);
 480           if (((sun_info.type == RT_ENCODED) &&
 481                (length > (bytes_per_line*image->rows))) ||
 482               ((sun_info.type != RT_ENCODED) && (length > sun_info.length)))
 483             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 484           for (y=0; y < (ssize_t) image->rows; y++)
 485           {
 486             q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 487             if (q == (const Quantum *) NULL)
 488               break;
 489             for (x=0; x < (ssize_t) image->columns; x++)
 490             {
 491               SetPixelIndex(image,*p++,q);
 492               q+=GetPixelChannels(image);
 493             }
 494             if ((image->columns % 2) != 0)
 495               p++;
 496             if (SyncAuthenticPixels(image,exception) == MagickFalse)
 497               break;
 498             if (image->previous == (Image *) NULL)
 499               {
 500                 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 501                 image->rows);
 502                 if (status == MagickFalse)
 503                   break;
 504               }
 505           }
 506         }
 507       else
 508         {
 509           size_t
 510             bytes_per_pixel;
 511
 512           bytes_per_pixel=3;
 513           if (image->matte != MagickFalse)
 514             bytes_per_pixel++;
 515           length=image->rows*((bytes_per_line*image->columns)+
 516             image->columns % 2);
 517           if (((sun_info.type == RT_ENCODED) &&
 518                (length > (bytes_per_line*image->rows))) ||
 519               ((sun_info.type != RT_ENCODED) && (length > sun_info.length)))
 520             ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 521           for (y=0; y < (ssize_t) image->rows; y++)
 522           {
 523             q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 524             if (q == (const Quantum *) NULL)
 525               break;
 526             for (x=0; x < (ssize_t) image->columns; x++)
 527             {
 528               if (image->matte != MagickFalse)
 529                 SetPixelAlpha(image,ScaleCharToQuantum(*p++),q);
 530               if (sun_info.type == RT_STANDARD)
 531                 {
 532                   SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
 533                   SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
 534                   SetPixelRed(image,ScaleCharToQuantum(*p++),q);
 535                 }
 536               else
 537                 {
 538                   SetPixelRed(image,ScaleCharToQuantum(*p++),q);
 539                   SetPixelGreen(image,ScaleCharToQuantum(*p++),q);
 540                   SetPixelBlue(image,ScaleCharToQuantum(*p++),q);
 541                 }
 542               if (image->colors != 0)
 543                 {
 544                   SetPixelRed(image,image->colormap[(ssize_t)
 545                     GetPixelRed(image,q)].red,q);
 546                   SetPixelGreen(image,image->colormap[(ssize_t)
 547                     GetPixelGreen(image,q)].green,q);
 548                   SetPixelBlue(image,image->colormap[(ssize_t)
 549                     GetPixelBlue(image,q)].blue,q);
 550                 }
 551               q+=GetPixelChannels(image);
 552             }
 553             if (((bytes_per_pixel*image->columns) % 2) != 0)
 554               p++;
 555             if (SyncAuthenticPixels(image,exception) == MagickFalse)
 556               break;
 557             if (image->previous == (Image *) NULL)
 558               {
 559                 status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 560                 image->rows);
 561                 if (status == MagickFalse)
 562                   break;
 563               }
 564           }
 565         }
 566     if (image->storage_class == PseudoClass)
 567       (void) SyncImage(image);
 568     sun_pixels=(unsigned char *) RelinquishMagickMemory(sun_pixels);
 569     if (EOFBlob(image) != MagickFalse)
 570       {
 571         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 572           image->filename);
 573         break;
 574       }
 575     /*
 576       Proceed to next image.
 577     */
 578     if (image_info->number_scenes != 0)
 579       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 580         break;
 581     sun_info.magic=ReadBlobMSBLong(image);
 582     if (sun_info.magic == 0x59a66a95)
 583       {
 584         /*
 585           Allocate next image structure.
 586         */
 587         AcquireNextImage(image_info,image);
 588         if (GetNextImageInList(image) == (Image *) NULL)
 589           {
 590             image=DestroyImageList(image);
 591             return((Image *) NULL);
 592           }
 593         image=SyncNextImageInList(image);
 594         status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
 595           GetBlobSize(image));
 596         if (status == MagickFalse)
 597           break;
 598       }
 599   } while (sun_info.magic == 0x59a66a95);
 600   (void) CloseBlob(image);
 601   return(GetFirstImageInList(image));
 602 }
 603 \f
 604 /*
 605 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 606 %                                                                             %
 607 %                                                                             %
 608 %                                                                             %
 609 %   R e g i s t e r S U N I m a g e                                           %
 610 %                                                                             %
 611 %                                                                             %
 612 %                                                                             %
 613 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 614 %
 615 %  RegisterSUNImage() adds attributes for the SUN image format to
 616 %  the list of supported formats.  The attributes include the image format
 617 %  tag, a method to read and/or write the format, whether the format
 618 %  supports the saving of more than one frame to the same file or blob,
 619 %  whether the format supports native in-memory I/O, and a brief
 620 %  description of the format.
 621 %
 622 %  The format of the RegisterSUNImage method is:
 623 %
 624 %      size_t RegisterSUNImage(void)
 625 %
 626 */
 627 ModuleExport size_t RegisterSUNImage(void)
 628 {
 629   MagickInfo
 630     *entry;
 631
 632   entry=SetMagickInfo("RAS");
 633   entry->decoder=(DecodeImageHandler *) ReadSUNImage;
 634   entry->encoder=(EncodeImageHandler *) WriteSUNImage;
 635   entry->magick=(IsImageFormatHandler *) IsSUN;
 636   entry->description=ConstantString("SUN Rasterfile");
 637   entry->module=ConstantString("SUN");
 638   (void) RegisterMagickInfo(entry);
 639   entry=SetMagickInfo("SUN");
 640   entry->decoder=(DecodeImageHandler *) ReadSUNImage;
 641   entry->encoder=(EncodeImageHandler *) WriteSUNImage;
 642   entry->description=ConstantString("SUN Rasterfile");
 643   entry->module=ConstantString("SUN");
 644   (void) RegisterMagickInfo(entry);
 645   return(MagickImageCoderSignature);
 646 }
 647 \f
 648 /*
 649 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 650 %                                                                             %
 651 %                                                                             %
 652 %                                                                             %
 653 %   U n r e g i s t e r S U N I m a g e                                       %
 654 %                                                                             %
 655 %                                                                             %
 656 %                                                                             %
 657 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 658 %
 659 %  UnregisterSUNImage() removes format registrations made by the
 660 %  SUN module from the list of supported formats.
 661 %
 662 %  The format of the UnregisterSUNImage method is:
 663 %
 664 %      UnregisterSUNImage(void)
 665 %
 666 */
 667 ModuleExport void UnregisterSUNImage(void)
 668 {
 669   (void) UnregisterMagickInfo("RAS");
 670   (void) UnregisterMagickInfo("SUN");
 671 }
 672 \f
 673 /*
 674 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 675 %                                                                             %
 676 %                                                                             %
 677 %                                                                             %
 678 %   W r i t e S U N I m a g e                                                 %
 679 %                                                                             %
 680 %                                                                             %
 681 %                                                                             %
 682 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 683 %
 684 %  WriteSUNImage() writes an image in the SUN rasterfile format.
 685 %
 686 %  The format of the WriteSUNImage method is:
 687 %
 688 %      MagickBooleanType WriteSUNImage(const ImageInfo *image_info,Image *image)
 689 %
 690 %  A description of each parameter follows.
 691 %
 692 %    o image_info: the image info.
 693 %
 694 %    o image:  The image.
 695 %
 696 */
 697 static MagickBooleanType WriteSUNImage(const ImageInfo *image_info,Image *image)
 698 {
 699 #define RMT_EQUAL_RGB  1
 700 #define RMT_NONE  0
 701 #define RMT_RAW  2
 702 #define RT_STANDARD  1
 703 #define RT_FORMAT_RGB  3
 704
 705   typedef struct _SUNInfo
 706   {
 707     unsigned int
 708       magic,
 709       width,
 710       height,
 711       depth,
 712       length,
 713       type,
 714       maptype,
 715       maplength;
 716   } SUNInfo;
 717
 718   MagickBooleanType
 719     status;
 720
 721   MagickOffsetType
 722     scene;
 723
 724   MagickSizeType
 725     number_pixels;
 726
 727   register const Quantum
 728     *p;
 729
 730   register ssize_t
 731     i,
 732     x;
 733
 734   ssize_t
 735     y;
 736
 737   SUNInfo
 738     sun_info;
 739
 740   /*
 741     Open output image file.
 742   */
 743   assert(image_info != (const ImageInfo *) NULL);
 744   assert(image_info->signature == MagickSignature);
 745   assert(image != (Image *) NULL);
 746   assert(image->signature == MagickSignature);
 747   if (image->debug != MagickFalse)
 748     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 749   status=OpenBlob(image_info,image,WriteBinaryBlobMode,&image->exception);
 750   if (status == MagickFalse)
 751     return(status);
 752   scene=0;
 753   do
 754   {
 755     /*
 756       Initialize SUN raster file header.
 757     */
 758     if (IsRGBColorspace(image->colorspace) == MagickFalse)
 759       (void) TransformImageColorspace(image,RGBColorspace);
 760     sun_info.magic=0x59a66a95;
 761     if ((image->columns != (unsigned int) image->columns) ||
 762         (image->rows != (unsigned int) image->rows))
 763       ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
 764     sun_info.width=(unsigned int) image->columns;
 765     sun_info.height=(unsigned int) image->rows;
 766     sun_info.type=(unsigned int)
 767       (image->storage_class == DirectClass ? RT_FORMAT_RGB : RT_STANDARD);
 768     sun_info.maptype=RMT_NONE;
 769     sun_info.maplength=0;
 770     number_pixels=(MagickSizeType) image->columns*image->rows;
 771     if ((4*number_pixels) != (size_t) (4*number_pixels))
 772       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 773     if (image->storage_class == DirectClass)
 774       {
 775         /*
 776           Full color SUN raster.
 777         */
 778         sun_info.depth=(unsigned int) image->matte ? 32U : 24U;
 779         sun_info.length=(unsigned int) ((image->matte ? 4 : 3)*number_pixels);
 780         sun_info.length+=sun_info.length & 0x01 ? (unsigned int) image->rows :
 781           0;
 782       }
 783     else
 784       if (IsImageMonochrome(image,&image->exception))
 785         {
 786           /*
 787             Monochrome SUN raster.
 788           */
 789           sun_info.depth=1;
 790           sun_info.length=(unsigned int) (((image->columns+7) >> 3)*
 791             image->rows);
 792           sun_info.length+=(unsigned int) (((image->columns/8)+(image->columns %
 793             8 ? 1 : 0)) % 2 ? image->rows : 0);
 794         }
 795       else
 796         {
 797           /*
 798             Colormapped SUN raster.
 799           */
 800           sun_info.depth=8;
 801           sun_info.length=(unsigned int) number_pixels;
 802           sun_info.length+=(unsigned int) (image->columns & 0x01 ? image->rows :
 803             0);
 804           sun_info.maptype=RMT_EQUAL_RGB;
 805           sun_info.maplength=(unsigned int) (3*image->colors);
 806         }
 807     /*
 808       Write SUN header.
 809     */
 810     (void) WriteBlobMSBLong(image,sun_info.magic);
 811     (void) WriteBlobMSBLong(image,sun_info.width);
 812     (void) WriteBlobMSBLong(image,sun_info.height);
 813     (void) WriteBlobMSBLong(image,sun_info.depth);
 814     (void) WriteBlobMSBLong(image,sun_info.length);
 815     (void) WriteBlobMSBLong(image,sun_info.type);
 816     (void) WriteBlobMSBLong(image,sun_info.maptype);
 817     (void) WriteBlobMSBLong(image,sun_info.maplength);
 818     /*
 819       Convert MIFF to SUN raster pixels.
 820     */
 821     x=0;
 822     y=0;
 823     if (image->storage_class == DirectClass)
 824       {
 825         register unsigned char
 826           *q;
 827
 828         size_t
 829           bytes_per_pixel,
 830           length;
 831
 832         unsigned char
 833           *pixels;
 834
 835         /*
 836           Allocate memory for pixels.
 837         */
 838         bytes_per_pixel=3;
 839         if (image->matte != MagickFalse)
 840           bytes_per_pixel++;
 841         length=image->columns;
 842         pixels=(unsigned char *) AcquireQuantumMemory(length,4*sizeof(*pixels));
 843         if (pixels == (unsigned char *) NULL)
 844           ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 845         /*
 846           Convert DirectClass packet to SUN RGB pixel.
 847         */
 848         for (y=0; y < (ssize_t) image->rows; y++)
 849         {
 850           p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
 851           if (p == (const Quantum *) NULL)
 852             break;
 853           q=pixels;
 854           for (x=0; x < (ssize_t) image->columns; x++)
 855           {
 856             if (image->matte != MagickFalse)
 857               *q++=ScaleQuantumToChar(GetPixelAlpha(image,p));
 858             *q++=ScaleQuantumToChar(GetPixelRed(image,p));
 859             *q++=ScaleQuantumToChar(GetPixelGreen(image,p));
 860             *q++=ScaleQuantumToChar(GetPixelBlue(image,p));
 861             p+=GetPixelChannels(image);
 862           }
 863           if (((bytes_per_pixel*image->columns) & 0x01) != 0)
 864             *q++='\0';  /* pad scanline */
 865           (void) WriteBlob(image,(size_t) (q-pixels),pixels);
 866           if (image->previous == (Image *) NULL)
 867             {
 868               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 869                 image->rows);
 870               if (status == MagickFalse)
 871                 break;
 872             }
 873         }
 874         pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 875       }
 876     else
 877       if (IsImageMonochrome(image,&image->exception))
 878         {
 879           register unsigned char
 880             bit,
 881             byte;
 882
 883           /*
 884             Convert PseudoClass image to a SUN monochrome image.
 885           */
 886           (void) SetImageType(image,BilevelType);
 887           for (y=0; y < (ssize_t) image->rows; y++)
 888           {
 889             p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
 890             if (p == (const Quantum *) NULL)
 891               break;
 892             bit=0;
 893             byte=0;
 894             for (x=0; x < (ssize_t) image->columns; x++)
 895             {
 896               byte<<=1;
 897               if (GetPixelIntensity(image,p) < (MagickRealType) (QuantumRange/2.0))
 898                 byte|=0x01;
 899               bit++;
 900               if (bit == 8)
 901                 {
 902                   (void) WriteBlobByte(image,byte);
 903                   bit=0;
 904                   byte=0;
 905                 }
 906               p+=GetPixelChannels(image);
 907             }
 908             if (bit != 0)
 909               (void) WriteBlobByte(image,(unsigned char) (byte << (8-bit)));
 910             if ((((image->columns/8)+
 911                 (image->columns % 8 ? 1 : 0)) % 2) != 0)
 912               (void) WriteBlobByte(image,0);  /* pad scanline */
 913             if (image->previous == (Image *) NULL)
 914               {
 915                 status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 916                 image->rows);
 917                 if (status == MagickFalse)
 918                   break;
 919               }
 920           }
 921         }
 922       else
 923         {
 924           /*
 925             Dump colormap to file.
 926           */
 927           for (i=0; i < (ssize_t) image->colors; i++)
 928             (void) WriteBlobByte(image,ScaleQuantumToChar(
 929               image->colormap[i].red));
 930           for (i=0; i < (ssize_t) image->colors; i++)
 931             (void) WriteBlobByte(image,ScaleQuantumToChar(
 932               image->colormap[i].green));
 933           for (i=0; i < (ssize_t) image->colors; i++)
 934             (void) WriteBlobByte(image,ScaleQuantumToChar(
 935               image->colormap[i].blue));
 936           /*
 937             Convert PseudoClass packet to SUN colormapped pixel.
 938           */
 939           for (y=0; y < (ssize_t) image->rows; y++)
 940           {
 941             p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
 942             if (p == (const Quantum *) NULL)
 943               break;
 944             for (x=0; x < (ssize_t) image->columns; x++)
 945             {
 946               (void) WriteBlobByte(image,(unsigned char)
 947                 GetPixelIndex(image,p));
 948               p+=GetPixelChannels(image);
 949             }
 950             if (image->columns & 0x01)
 951               (void) WriteBlobByte(image,0);  /* pad scanline */
 952             if (image->previous == (Image *) NULL)
 953               {
 954                 status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 955                   image->rows);
 956                 if (status == MagickFalse)
 957                   break;
 958               }
 959           }
 960         }
 961     if (GetNextImageInList(image) == (Image *) NULL)
 962       break;
 963     image=SyncNextImageInList(image);
 964     status=SetImageProgress(image,SaveImagesTag,scene++,
 965       GetImageListLength(image));
 966     if (status == MagickFalse)
 967       break;
 968   } while (image_info->adjoin != MagickFalse);
 969   (void) CloseBlob(image);
 970   return(MagickTrue);
 971 }