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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            H   H  DDDD   RRRR                               %
   7 %                            H   H  D   D  R   R                              %
   8 %                            HHHHH  D   D  RRRR                               %
   9 %                            H   H  D   D  R R                                %
  10 %                            H   H  DDDD   R  R                               %
  11 %                                                                             %
  12 %                                                                             %
  13 %                   Read/Write Radiance RGBE 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/blob.h"
  44 #include "MagickCore/blob-private.h"
  45 #include "MagickCore/cache.h"
  46 #include "MagickCore/colorspace.h"
  47 #include "MagickCore/colorspace-private.h"
  48 #include "MagickCore/exception.h"
  49 #include "MagickCore/exception-private.h"
  50 #include "MagickCore/image.h"
  51 #include "MagickCore/image-private.h"
  52 #include "MagickCore/list.h"
  53 #include "MagickCore/magick.h"
  54 #include "MagickCore/memory_.h"
  55 #include "MagickCore/monitor.h"
  56 #include "MagickCore/monitor-private.h"
  57 #include "MagickCore/pixel-accessor.h"
  58 #include "MagickCore/property.h"
  59 #include "MagickCore/quantum-private.h"
  60 #include "MagickCore/static.h"
  61 #include "MagickCore/string_.h"
  62 #include "MagickCore/string-private.h"
  63 #include "MagickCore/module.h"
  64 \f
  65 /*
  66   Forward declarations.
  67 */
  68 static MagickBooleanType
  69   WriteHDRImage(const ImageInfo *,Image *,ExceptionInfo *);
  70 \f
  71 /*
  72 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  73 %                                                                             %
  74 %                                                                             %
  75 %                                                                             %
  76 %   I s H D R                                                                 %
  77 %                                                                             %
  78 %                                                                             %
  79 %                                                                             %
  80 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  81 %
  82 %  IsHDR() returns MagickTrue if the image format type, identified by the
  83 %  magick string, is Radiance RGBE image format.
  84 %
  85 %  The format of the IsHDR method is:
  86 %
  87 %      MagickBooleanType IsHDR(const unsigned char *magick,
  88 %        const size_t length)
  89 %
  90 %  A description of each parameter follows:
  91 %
  92 %    o magick: compare image format pattern against these bytes.
  93 %
  94 %    o length: Specifies the length of the magick string.
  95 %
  96 */
  97 static MagickBooleanType IsHDR(const unsigned char *magick,
  98   const size_t length)
  99 {
 100   if (length < 10)
 101     return(MagickFalse);
 102   if (LocaleNCompare((const char *) magick,"#?RADIANCE",10) == 0)
 103     return(MagickTrue);
 104   if (LocaleNCompare((const char *) magick,"#?RGBE",6) == 0)
 105     return(MagickTrue);
 106   return(MagickFalse);
 107 }
 108 \f
 109 /*
 110 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 111 %                                                                             %
 112 %                                                                             %
 113 %                                                                             %
 114 %   R e a d H D R I m a g e                                                   %
 115 %                                                                             %
 116 %                                                                             %
 117 %                                                                             %
 118 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 119 %
 120 %  ReadHDRImage() reads the Radiance RGBE image format and returns it.  It
 121 %  allocates the memory necessary for the new Image structure and returns a
 122 %  pointer to the new image.
 123 %
 124 %  The format of the ReadHDRImage method is:
 125 %
 126 %      Image *ReadHDRImage(const ImageInfo *image_info,ExceptionInfo *exception)
 127 %
 128 %  A description of each parameter follows:
 129 %
 130 %    o image_info: the image info.
 131 %
 132 %    o exception: return any errors or warnings in this structure.
 133 %
 134 */
 135 static Image *ReadHDRImage(const ImageInfo *image_info,ExceptionInfo *exception)
 136 {
 137   char
 138     format[MaxTextExtent],
 139     keyword[MaxTextExtent],
 140     tag[MaxTextExtent],
 141     value[MaxTextExtent];
 142
 143   double
 144     gamma;
 145
 146   Image
 147     *image;
 148
 149   int
 150     c;
 151
 152   MagickBooleanType
 153     status,
 154     value_expected;
 155
 156   register Quantum
 157     *q;
 158
 159   register ssize_t
 160     i,
 161     x;
 162
 163   register unsigned char
 164     *p;
 165
 166   ssize_t
 167     count,
 168     y;
 169
 170   unsigned char
 171     *end,
 172     pixel[4],
 173     *pixels;
 174
 175   /*
 176     Open image file.
 177   */
 178   assert(image_info != (const ImageInfo *) NULL);
 179   assert(image_info->signature == MagickSignature);
 180   if (image_info->debug != MagickFalse)
 181     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 182       image_info->filename);
 183   assert(exception != (ExceptionInfo *) NULL);
 184   assert(exception->signature == MagickSignature);
 185   image=AcquireImage(image_info);
 186   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 187   if (status == MagickFalse)
 188     {
 189       image=DestroyImageList(image);
 190       return((Image *) NULL);
 191     }
 192   /*
 193     Decode image header.
 194   */
 195   image->columns=0;
 196   image->rows=0;
 197   *format='\0';
 198   c=ReadBlobByte(image);
 199   if (c == EOF)
 200     {
 201       image=DestroyImage(image);
 202       return((Image *) NULL);
 203     }
 204   while (isgraph(c) && (image->columns == 0) && (image->rows == 0))
 205   {
 206     if (c == (int) '#')
 207       {
 208         char
 209           *comment;
 210
 211         register char
 212           *p;
 213
 214         size_t
 215           length;
 216
 217         /*
 218           Read comment-- any text between # and end-of-line.
 219         */
 220         length=MaxTextExtent;
 221         comment=AcquireString((char *) NULL);
 222         for (p=comment; comment != (char *) NULL; p++)
 223         {
 224           c=ReadBlobByte(image);
 225           if ((c == EOF) || (c == (int) '\n'))
 226             break;
 227           if ((size_t) (p-comment+1) >= length)
 228             {
 229               *p='\0';
 230               length<<=1;
 231               comment=(char *) ResizeQuantumMemory(comment,length+
 232                 MaxTextExtent,sizeof(*comment));
 233               if (comment == (char *) NULL)
 234                 break;
 235               p=comment+strlen(comment);
 236             }
 237           *p=(char) c;
 238         }
 239         if (comment == (char *) NULL)
 240           ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 241         *p='\0';
 242         (void) SetImageProperty(image,"comment",comment);
 243         comment=DestroyString(comment);
 244         c=ReadBlobByte(image);
 245       }
 246     else
 247       if (isalnum(c) == MagickFalse)
 248         c=ReadBlobByte(image);
 249       else
 250         {
 251           register char
 252             *p;
 253
 254           /*
 255             Determine a keyword and its value.
 256           */
 257           p=keyword;
 258           do
 259           {
 260             if ((size_t) (p-keyword) < (MaxTextExtent-1))
 261               *p++=c;
 262             c=ReadBlobByte(image);
 263           } while (isalnum(c) || (c == '_'));
 264           *p='\0';
 265           value_expected=MagickFalse;
 266           while ((isspace((int) ((unsigned char) c)) != 0) || (c == '='))
 267           {
 268             if (c == '=')
 269               value_expected=MagickTrue;
 270             c=ReadBlobByte(image);
 271           }
 272           if (LocaleCompare(keyword,"Y") == 0)
 273             value_expected=MagickTrue;
 274           if (value_expected == MagickFalse)
 275             continue;
 276           p=value;
 277           while ((c != '\n') && (c != '\0'))
 278           {
 279             if ((size_t) (p-value) < (MaxTextExtent-1))
 280               *p++=c;
 281             c=ReadBlobByte(image);
 282           }
 283           *p='\0';
 284           /*
 285             Assign a value to the specified keyword.
 286           */
 287           switch (*keyword)
 288           {
 289             case 'F':
 290             case 'f':
 291             {
 292               if (LocaleCompare(keyword,"format") == 0)
 293                 {
 294                   (void) CopyMagickString(format,value,MaxTextExtent);
 295                   break;
 296                 }
 297               (void) FormatLocaleString(tag,MaxTextExtent,"hdr:%s",keyword);
 298               (void) SetImageProperty(image,tag,value);
 299               break;
 300             }
 301             case 'G':
 302             case 'g':
 303             {
 304               if (LocaleCompare(keyword,"gamma") == 0)
 305                 {
 306                   image->gamma=InterpretLocaleValue(value,(char **) NULL);
 307                   break;
 308                 }
 309               (void) FormatLocaleString(tag,MaxTextExtent,"hdr:%s",keyword);
 310               (void) SetImageProperty(image,tag,value);
 311               break;
 312             }
 313             case 'P':
 314             case 'p':
 315             {
 316               if (LocaleCompare(keyword,"primaries") == 0)
 317                 {
 318                   float
 319                     chromaticity[6],
 320                     white_point[2];
 321
 322                   (void) sscanf(value,"%g %g %g %g %g %g %g %g",
 323                     &chromaticity[0],&chromaticity[1],&chromaticity[2],
 324                     &chromaticity[3],&chromaticity[4],&chromaticity[5],
 325                     &white_point[0],&white_point[1]);
 326                   image->chromaticity.red_primary.x=chromaticity[0];
 327                   image->chromaticity.red_primary.y=chromaticity[1];
 328                   image->chromaticity.green_primary.x=chromaticity[2];
 329                   image->chromaticity.green_primary.y=chromaticity[3];
 330                   image->chromaticity.blue_primary.x=chromaticity[4];
 331                   image->chromaticity.blue_primary.y=chromaticity[5];
 332                   image->chromaticity.white_point.x=white_point[0],
 333                   image->chromaticity.white_point.y=white_point[1];
 334                   break;
 335                 }
 336               (void) FormatLocaleString(tag,MaxTextExtent,"hdr:%s",keyword);
 337               (void) SetImageProperty(image,tag,value);
 338               break;
 339             }
 340             case 'Y':
 341             case 'y':
 342             {
 343               if (strcmp(keyword,"Y") == 0)
 344                 {
 345                   int
 346                     height,
 347                     width;
 348
 349                   (void) sscanf(value,"%d +X %d",&height,&width);
 350                   image->columns=(size_t) width;
 351                   image->rows=(size_t) height;
 352                   break;
 353                 }
 354               (void) FormatLocaleString(tag,MaxTextExtent,"hdr:%s",keyword);
 355               (void) SetImageProperty(image,tag,value);
 356               break;
 357             }
 358             default:
 359             {
 360               (void) FormatLocaleString(tag,MaxTextExtent,"hdr:%s",keyword);
 361               (void) SetImageProperty(image,tag,value);
 362               break;
 363             }
 364           }
 365         }
 366     if ((image->columns == 0) && (image->rows == 0))
 367       while (isspace((int) ((unsigned char) c)) != 0)
 368         c=ReadBlobByte(image);
 369   }
 370   if ((LocaleCompare(format,"32-bit_rle_rgbe") != 0) &&
 371       (LocaleCompare(format,"32-bit_rle_xyze") != 0))
 372     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 373   if ((image->columns == 0) || (image->rows == 0))
 374     ThrowReaderException(CorruptImageError,"NegativeOrZeroImageSize");
 375   if (LocaleCompare(format,"32-bit_rle_xyze") == 0)
 376     image->colorspace=XYZColorspace;
 377   image->compression=(image->columns < 8) || (image->columns > 0x7ffff) ?
 378     NoCompression : RLECompression;
 379   if (image_info->ping != MagickFalse)
 380     {
 381       (void) CloseBlob(image);
 382       return(GetFirstImageInList(image));
 383     }
 384   /*
 385     Read RGBE (red+green+blue+exponent) pixels.
 386   */
 387   pixels=(unsigned char *) AcquireQuantumMemory(image->columns,4*
 388     sizeof(*pixels));
 389   if (pixels == (unsigned char *) NULL)
 390     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 391   for (y=0; y < (ssize_t) image->rows; y++)
 392   {
 393     if (image->compression != RLECompression)
 394       {
 395         count=ReadBlob(image,4*image->columns*sizeof(*pixels),pixels);
 396         if (count != (ssize_t) (4*image->columns*sizeof(*pixels)))
 397           break;
 398       }
 399     else
 400       {
 401         count=ReadBlob(image,4*sizeof(*pixel),pixel);
 402         if (count != 4)
 403           break;
 404         if ((size_t) ((((size_t) pixel[2]) << 8) | pixel[3]) != image->columns)
 405           {
 406             (void) memcpy(pixels,pixel,4*sizeof(*pixel));
 407             count=ReadBlob(image,4*(image->columns-1)*sizeof(*pixels),pixels+4);
 408             image->compression=NoCompression;
 409           }
 410         else
 411           {
 412             p=pixels;
 413             for (i=0; i < 4; i++)
 414             {
 415               end=&pixels[(i+1)*image->columns];
 416               while (p < end)
 417               {
 418                 count=ReadBlob(image,2*sizeof(*pixel),pixel);
 419                 if (count < 1)
 420                   break;
 421                 if (pixel[0] > 128)
 422                   {
 423                     count=(ssize_t) pixel[0]-128;
 424                     if ((count == 0) || (count > (ssize_t) (end-p)))
 425                       break;
 426                     while (count-- > 0)
 427                       *p++=pixel[1];
 428                   }
 429                 else
 430                   {
 431                     count=(ssize_t) pixel[0];
 432                     if ((count == 0) || (count > (ssize_t) (end-p)))
 433                       break;
 434                     *p++=pixel[1];
 435                     if (--count > 0)
 436                       {
 437                         count=ReadBlob(image,(size_t) count*sizeof(*p),p);
 438                         if (count < 1)
 439                           break;
 440                         p+=count;
 441                       }
 442                   }
 443               }
 444             }
 445           }
 446       }
 447     q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 448     if (q == (Quantum *) NULL)
 449       break;
 450     i=0;
 451     for (x=0; x < (ssize_t) image->columns; x++)
 452     {
 453       if (image->compression == RLECompression)
 454         {
 455           pixel[0]=pixels[x];
 456           pixel[1]=pixels[x+image->columns];
 457           pixel[2]=pixels[x+2*image->columns];
 458           pixel[3]=pixels[x+3*image->columns];
 459         }
 460       else
 461         {
 462           pixel[0]=pixels[i++];
 463           pixel[1]=pixels[i++];
 464           pixel[2]=pixels[i++];
 465           pixel[3]=pixels[i++];
 466         }
 467       SetPixelRed(image,0,q);
 468       SetPixelGreen(image,0,q);
 469       SetPixelBlue(image,0,q);
 470       if (pixel[3] != 0)
 471         {
 472           gamma=pow(2.0,pixel[3]-(128.0+8.0));
 473           SetPixelRed(image,ClampToQuantum(QuantumRange*gamma*pixel[0]),q);
 474           SetPixelGreen(image,ClampToQuantum(QuantumRange*gamma*pixel[1]),q);
 475           SetPixelBlue(image,ClampToQuantum(QuantumRange*gamma*pixel[2]),q);
 476         }
 477       q+=GetPixelChannels(image);
 478     }
 479     if (SyncAuthenticPixels(image,exception) == MagickFalse)
 480       break;
 481     status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 482       image->rows);
 483     if (status == MagickFalse)
 484       break;
 485   }
 486   pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 487   if (EOFBlob(image) != MagickFalse)
 488     ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 489       image->filename);
 490   (void) CloseBlob(image);
 491   return(GetFirstImageInList(image));
 492 }
 493 \f
 494 /*
 495 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 496 %                                                                             %
 497 %                                                                             %
 498 %                                                                             %
 499 %   R e g i s t e r H D R I m a g e                                           %
 500 %                                                                             %
 501 %                                                                             %
 502 %                                                                             %
 503 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 504 %
 505 %  RegisterHDRImage() adds attributes for the Radiance RGBE image format to the
 506 %  list of supported formats.  The attributes include the image format tag, a
 507 %  method to read and/or write the format, whether the format supports the
 508 %  saving of more than one frame to the same file or blob, whether the format
 509 %  supports native in-memory I/O, and a brief description of the format.
 510 %
 511 %  The format of the RegisterHDRImage method is:
 512 %
 513 %      size_t RegisterHDRImage(void)
 514 %
 515 */
 516 ModuleExport size_t RegisterHDRImage(void)
 517 {
 518   MagickInfo
 519     *entry;
 520
 521   entry=SetMagickInfo("HDR");
 522   entry->decoder=(DecodeImageHandler *) ReadHDRImage;
 523   entry->encoder=(EncodeImageHandler *) WriteHDRImage;
 524   entry->description=ConstantString("Radiance RGBE image format");
 525   entry->module=ConstantString("HDR");
 526   entry->magick=(IsImageFormatHandler *) IsHDR;
 527   (void) RegisterMagickInfo(entry);
 528   return(MagickImageCoderSignature);
 529 }
 530 \f
 531 /*
 532 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 533 %                                                                             %
 534 %                                                                             %
 535 %                                                                             %
 536 %   U n r e g i s t e r H D R I m a g e                                       %
 537 %                                                                             %
 538 %                                                                             %
 539 %                                                                             %
 540 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 541 %
 542 %  UnregisterHDRImage() removes format registrations made by the
 543 %  HDR module from the list of supported formats.
 544 %
 545 %  The format of the UnregisterHDRImage method is:
 546 %
 547 %      UnregisterHDRImage(void)
 548 %
 549 */
 550 ModuleExport void UnregisterHDRImage(void)
 551 {
 552   (void) UnregisterMagickInfo("HDR");
 553 }
 554 \f
 555 /*
 556 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 557 %                                                                             %
 558 %                                                                             %
 559 %                                                                             %
 560 %   W r i t e H D R I m a g e                                                 %
 561 %                                                                             %
 562 %                                                                             %
 563 %                                                                             %
 564 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 565 %
 566 %  WriteHDRImage() writes an image in the Radience RGBE image format.
 567 %
 568 %  The format of the WriteHDRImage method is:
 569 %
 570 %      MagickBooleanType WriteHDRImage(const ImageInfo *image_info,
 571 %        Image *image,ExceptionInfo *exception)
 572 %
 573 %  A description of each parameter follows.
 574 %
 575 %    o image_info: the image info.
 576 %
 577 %    o image:  The image.
 578 %
 579 */
 580
 581 static size_t HDRWriteRunlengthPixels(Image *image,unsigned char *pixels)
 582 {
 583 #define MinimumRunlength 4
 584
 585   register size_t
 586     p,
 587     q;
 588
 589   size_t
 590     runlength;
 591
 592   ssize_t
 593     count,
 594     previous_count;
 595
 596   unsigned char
 597     pixel[2];
 598
 599   for (p=0; p < image->columns; )
 600   {
 601     q=p;
 602     runlength=0;
 603     previous_count=0;
 604     while ((runlength < MinimumRunlength) && (q < image->columns))
 605     {
 606       q+=runlength;
 607       previous_count=(ssize_t) runlength;
 608       runlength=1;
 609       while ((pixels[q] == pixels[q+runlength]) &&
 610              ((q+runlength) < image->columns) && (runlength < 127))
 611        runlength++;
 612     }
 613     if ((previous_count > 1) && (previous_count == (ssize_t) (q-p)))
 614       {
 615         pixel[0]=(unsigned char) (128+previous_count);
 616         pixel[1]=pixels[p];
 617         if (WriteBlob(image,2*sizeof(*pixel),pixel) < 1)
 618           break;
 619         p=q;
 620       }
 621     while (p < q)
 622     {
 623       count=(ssize_t) (q-p);
 624       if (count > 128)
 625         count=128;
 626       pixel[0]=(unsigned char) count;
 627       if (WriteBlob(image,sizeof(*pixel),pixel) < 1)
 628         break;
 629       if (WriteBlob(image,(size_t) count*sizeof(*pixel),&pixels[p]) < 1)
 630         break;
 631       p+=count;
 632     }
 633     if (runlength >= MinimumRunlength)
 634       {
 635         pixel[0]=(unsigned char) (128+runlength);
 636         pixel[1]=pixels[q];
 637         if (WriteBlob(image,2*sizeof(*pixel),pixel) < 1)
 638           break;
 639         p+=runlength;
 640       }
 641   }
 642   return(p);
 643 }
 644
 645 static MagickBooleanType WriteHDRImage(const ImageInfo *image_info,Image *image,
 646   ExceptionInfo *exception)
 647 {
 648   char
 649     header[MaxTextExtent];
 650
 651   const char
 652     *property;
 653
 654   MagickBooleanType
 655     status;
 656
 657   register const Quantum
 658     *p;
 659
 660   register ssize_t
 661     i,
 662     x;
 663
 664   size_t
 665     length;
 666
 667   ssize_t
 668     count,
 669     y;
 670
 671   unsigned char
 672     pixel[4],
 673     *pixels;
 674
 675   /*
 676     Open output image file.
 677   */
 678   assert(image_info != (const ImageInfo *) NULL);
 679   assert(image_info->signature == MagickSignature);
 680   assert(image != (Image *) NULL);
 681   assert(image->signature == MagickSignature);
 682   if (image->debug != MagickFalse)
 683     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 684   assert(exception != (ExceptionInfo *) NULL);
 685   assert(exception->signature == MagickSignature);
 686   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
 687   if (status == MagickFalse)
 688     return(status);
 689   if (IsRGBColorspace(image->colorspace) == MagickFalse)
 690     (void) TransformImageColorspace(image,RGBColorspace);
 691   /*
 692     Write header.
 693   */
 694   (void) ResetMagickMemory(header,' ',MaxTextExtent);
 695   length=CopyMagickString(header,"#?RGBE\n",MaxTextExtent);
 696   (void) WriteBlob(image,length,(unsigned char *) header);
 697   property=GetImageProperty(image,"comment");
 698   if ((property != (const char *) NULL) &&
 699       (strchr(property,'\n') == (char *) NULL))
 700     {
 701       count=FormatLocaleString(header,MaxTextExtent,"#%s\n",property);
 702       (void) WriteBlob(image,(size_t) count,(unsigned char *) header);
 703     }
 704   property=GetImageProperty(image,"hdr:exposure");
 705   if (property != (const char *) NULL)
 706     {
 707       count=FormatLocaleString(header,MaxTextExtent,"EXPOSURE=%g\n",
 708         atof(property));
 709       (void) WriteBlob(image,(size_t) count,(unsigned char *) header);
 710     }
 711   if (image->gamma != 0.0)
 712     {
 713       count=FormatLocaleString(header,MaxTextExtent,"GAMMA=%g\n",image->gamma);
 714       (void) WriteBlob(image,(size_t) count,(unsigned char *) header);
 715     }
 716   count=FormatLocaleString(header,MaxTextExtent,
 717     "PRIMARIES=%g %g %g %g %g %g %g %g\n",
 718     image->chromaticity.red_primary.x,image->chromaticity.red_primary.y,
 719     image->chromaticity.green_primary.x,image->chromaticity.green_primary.y,
 720     image->chromaticity.blue_primary.x,image->chromaticity.blue_primary.y,
 721     image->chromaticity.white_point.x,image->chromaticity.white_point.y);
 722   (void) WriteBlob(image,(size_t) count,(unsigned char *) header);
 723   length=CopyMagickString(header,"FORMAT=32-bit_rle_rgbe\n\n",MaxTextExtent);
 724   (void) WriteBlob(image,length,(unsigned char *) header);
 725   count=FormatLocaleString(header,MaxTextExtent,"-Y %.20g +X %.20g\n",
 726     (double) image->rows,(double) image->columns);
 727   (void) WriteBlob(image,(size_t) count,(unsigned char *) header);
 728   /*
 729     Write HDR pixels.
 730   */
 731   pixels=(unsigned char *) AcquireQuantumMemory(image->columns,4*
 732     sizeof(*pixels));
 733   if (pixels == (unsigned char *) NULL)
 734     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 735   for (y=0; y < (ssize_t) image->rows; y++)
 736   {
 737     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 738     if (p == (const Quantum *) NULL)
 739       break;
 740     if ((image->columns >= 8) && (image->columns <= 0x7ffff))
 741       {
 742         pixel[0]=2;
 743         pixel[1]=2;
 744         pixel[2]=(unsigned char) (image->columns >> 8);
 745         pixel[3]=(unsigned char) (image->columns & 0xff);
 746         count=WriteBlob(image,4*sizeof(*pixel),pixel);
 747         if (count != (ssize_t) (4*sizeof(*pixel)))
 748           break;
 749       }
 750     i=0;
 751     for (x=0; x < (ssize_t) image->columns; x++)
 752     {
 753       double
 754         gamma;
 755
 756       pixel[0]=0;
 757       pixel[1]=0;
 758       pixel[2]=0;
 759       pixel[3]=0;
 760       gamma=QuantumScale*GetPixelRed(image,p);
 761       if ((QuantumScale*GetPixelGreen(image,p)) > gamma)
 762         gamma=QuantumScale*GetPixelGreen(image,p);
 763       if ((QuantumScale*GetPixelBlue(image,p)) > gamma)
 764         gamma=QuantumScale*GetPixelBlue(image,p);
 765       if (gamma > MagickEpsilon)
 766         {
 767           int
 768             exponent;
 769
 770           gamma=frexp(gamma,&exponent)*256.0/gamma;
 771           pixel[0]=(unsigned char) (gamma*QuantumScale*GetPixelRed(image,p));
 772           pixel[1]=(unsigned char) (gamma*QuantumScale*GetPixelGreen(image,p));
 773           pixel[2]=(unsigned char) (gamma*QuantumScale*GetPixelBlue(image,p));
 774           pixel[3]=(unsigned char) (exponent+128);
 775         }
 776       if ((image->columns >= 8) && (image->columns <= 0x7ffff))
 777         {
 778           pixels[x]=pixel[0];
 779           pixels[x+image->columns]=pixel[1];
 780           pixels[x+2*image->columns]=pixel[2];
 781           pixels[x+3*image->columns]=pixel[3];
 782         }
 783       else
 784         {
 785           pixels[i++]=pixel[0];
 786           pixels[i++]=pixel[1];
 787           pixels[i++]=pixel[2];
 788           pixels[i++]=pixel[3];
 789         }
 790       p+=GetPixelChannels(image);
 791     }
 792     if ((image->columns >= 8) && (image->columns <= 0x7ffff))
 793       {
 794         for (i=0; i < 4; i++)
 795           length=HDRWriteRunlengthPixels(image,&pixels[i*image->columns]);
 796       }
 797     else
 798       {
 799         count=WriteBlob(image,4*image->columns*sizeof(*pixel),pixel);
 800         if (count != (ssize_t) (4*image->columns*sizeof(*pixel)))
 801           break;
 802       }
 803     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 804       image->rows);
 805     if (status == MagickFalse)
 806       break;
 807   }
 808   pixels=(unsigned char *) RelinquishMagickMemory(pixels);
 809   (void) CloseBlob(image);
 810   return(MagickTrue);
 811 }