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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            DDDD   PPPP   X   X                              %
   7 %                            D   D  P   P   X X                               %
   8 %                            D   D  PPPP    XXX                               %
   9 %                            D   D  P       X X                               %
  10 %                            DDDD   P      X   X                              %
  11 %                                                                             %
  12 %                                                                             %
  13 %                     Read/Write SMTPE DPX Image Format                       %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                   Cristy                                    %
  17 %                                March 2001                                   %
  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/artifact.h"
  45 #include "MagickCore/blob.h"
  46 #include "MagickCore/blob-private.h"
  47 #include "MagickCore/cache.h"
  48 #include "MagickCore/colorspace.h"
  49 #include "MagickCore/exception.h"
  50 #include "MagickCore/exception-private.h"
  51 #include "MagickCore/geometry.h"
  52 #include "MagickCore/image.h"
  53 #include "MagickCore/image-private.h"
  54 #include "MagickCore/list.h"
  55 #include "MagickCore/magick.h"
  56 #include "MagickCore/memory_.h"
  57 #include "MagickCore/module.h"
  58 #include "MagickCore/monitor.h"
  59 #include "MagickCore/monitor-private.h"
  60 #include "MagickCore/option.h"
  61 #include "MagickCore/pixel-accessor.h"
  62 #include "MagickCore/profile.h"
  63 #include "MagickCore/property.h"
  64 #include "MagickCore/quantum-private.h"
  65 #include "MagickCore/static.h"
  66 #include "MagickCore/string_.h"
  67 #include "MagickCore/string-private.h"
  68 \f
  69 /*
  70   Typedef declaration.
  71 */
  72 typedef enum
  73 {
  74   UserDefinedColorimetric = 0,
  75   PrintingDensityColorimetric = 1,
  76   LinearColorimetric = 2,
  77   LogarithmicColorimetric = 3,
  78   UnspecifiedVideoColorimetric = 4,
  79   SMTPE_274MColorimetric = 5,
  80   ITU_R709Colorimetric = 6,
  81   ITU_R601_625LColorimetric = 7,
  82   ITU_R601_525LColorimetric = 8,
  83   NTSCCompositeVideoColorimetric = 9,
  84   PALCompositeVideoColorimetric = 10,
  85   ZDepthLinearColorimetric = 11,
  86   DepthHomogeneousColorimetric = 12
  87 } DPXColorimetric;
  88
  89 typedef enum
  90 {
  91   UndefinedComponentType = 0,
  92   RedComponentType = 1,
  93   GreenComponentType = 2,
  94   BlueComponentType = 3,
  95   AlphaComponentType = 4,
  96   LumaComponentType = 6,
  97   ColorDifferenceCbCrComponentType = 7,
  98   DepthComponentType = 8,
  99   CompositeVideoComponentType = 9,
 100   RGBComponentType = 50,
 101   RGBAComponentType = 51,
 102   ABGRComponentType = 52,
 103   CbYCrY422ComponentType = 100,
 104   CbYACrYA4224ComponentType = 101,
 105   CbYCr444ComponentType = 102,
 106   CbYCrA4444ComponentType = 103,
 107   UserDef2ElementComponentType = 150,
 108   UserDef3ElementComponentType = 151,
 109   UserDef4ElementComponentType = 152,
 110   UserDef5ElementComponentType = 153,
 111   UserDef6ElementComponentType = 154,
 112   UserDef7ElementComponentType = 155,
 113   UserDef8ElementComponentType = 156
 114 } DPXComponentType;
 115
 116 typedef enum
 117 {
 118   TransferCharacteristicUserDefined = 0,
 119   TransferCharacteristicPrintingDensity = 1,
 120   TransferCharacteristicLinear = 2,
 121   TransferCharacteristicLogarithmic = 3,
 122   TransferCharacteristicUnspecifiedVideo = 4,
 123   TransferCharacteristicSMTPE274M = 5,     /* 1920x1080 TV */
 124   TransferCharacteristicITU_R709 = 6,      /* ITU R709 */
 125   TransferCharacteristicITU_R601_625L = 7, /* 625 Line */
 126   TransferCharacteristicITU_R601_525L = 8, /* 525 Line */
 127   TransferCharacteristicNTSCCompositeVideo = 9,
 128   TransferCharacteristicPALCompositeVideo = 10,
 129   TransferCharacteristicZDepthLinear = 11,
 130   TransferCharacteristicZDepthHomogeneous = 12
 131 } DPXTransferCharacteristic;
 132
 133 typedef struct _DPXFileInfo
 134 {
 135   unsigned int
 136     magic,
 137     image_offset;
 138
 139   char
 140     version[8];
 141
 142   unsigned int
 143     file_size,
 144     ditto_key,
 145     generic_size,
 146     industry_size,
 147     user_size;
 148
 149   char
 150     filename[100],
 151     timestamp[24],
 152     creator[100],
 153     project[200],
 154     copyright[200];
 155
 156   unsigned int
 157     encrypt_key;
 158
 159   char
 160     reserve[104];
 161 } DPXFileInfo;
 162
 163 typedef struct _DPXFilmInfo
 164 {
 165   char
 166     id[2],
 167     type[2],
 168     offset[2],
 169     prefix[6],
 170     count[4],
 171     format[32];
 172
 173   unsigned int
 174     frame_position,
 175     sequence_extent,
 176     held_count;
 177
 178   float
 179     frame_rate,
 180     shutter_angle;
 181
 182   char
 183     frame_id[32],
 184     slate[100],
 185     reserve[56];
 186 } DPXFilmInfo;
 187
 188 typedef struct _DPXImageElement
 189 {
 190   unsigned int
 191     data_sign,
 192     low_data;
 193
 194   float
 195     low_quantity;
 196
 197   unsigned int
 198     high_data;
 199
 200   float
 201     high_quantity;
 202
 203   unsigned char
 204     descriptor,
 205     transfer_characteristic,
 206     colorimetric,
 207     bit_size;
 208
 209   unsigned short
 210     packing,
 211     encoding;
 212
 213   unsigned int
 214     data_offset,
 215     end_of_line_padding,
 216     end_of_image_padding;
 217
 218   unsigned char
 219     description[32];
 220 } DPXImageElement;
 221
 222 typedef struct _DPXImageInfo
 223 {
 224   unsigned short
 225     orientation,
 226     number_elements;
 227
 228   unsigned int
 229     pixels_per_line,
 230     lines_per_element;
 231
 232   DPXImageElement
 233     image_element[8];
 234
 235   unsigned char
 236     reserve[52];
 237 } DPXImageInfo;
 238
 239 typedef struct _DPXOrientationInfo
 240 {
 241   unsigned int
 242     x_offset,
 243     y_offset;
 244
 245   float
 246     x_center,
 247     y_center;
 248
 249   unsigned int
 250     x_size,
 251     y_size;
 252
 253   char
 254     filename[100],
 255     timestamp[24],
 256     device[32],
 257     serial[32];
 258
 259   unsigned short
 260     border[4];
 261
 262   unsigned int
 263     aspect_ratio[2];
 264
 265   unsigned char
 266     reserve[28];
 267 } DPXOrientationInfo;
 268
 269 typedef struct _DPXTelevisionInfo
 270 {
 271   unsigned int
 272     time_code,
 273     user_bits;
 274
 275   unsigned char
 276     interlace,
 277     field_number,
 278     video_signal,
 279     padding;
 280
 281   float
 282     horizontal_sample_rate,
 283     vertical_sample_rate,
 284     frame_rate,
 285     time_offset,
 286     gamma,
 287     black_level,
 288     black_gain,
 289     break_point,
 290     white_level,
 291     integration_times;
 292
 293   char
 294     reserve[76];
 295 } DPXTelevisionInfo;
 296
 297 typedef struct _DPXUserInfo
 298 {
 299   char
 300     id[32];
 301 } DPXUserInfo;
 302
 303 typedef struct DPXInfo
 304 {
 305   DPXFileInfo
 306     file;
 307
 308   DPXImageInfo
 309     image;
 310
 311   DPXOrientationInfo
 312     orientation;
 313
 314   DPXFilmInfo
 315     film;
 316
 317   DPXTelevisionInfo
 318     television;
 319
 320   DPXUserInfo
 321     user;
 322 } DPXInfo;
 323 \f
 324 /*
 325   Forward declaractions.
 326 */
 327 static MagickBooleanType
 328   WriteDPXImage(const ImageInfo *,Image *,ExceptionInfo *);
 329 \f
 330 /*
 331 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 332 %                                                                             %
 333 %                                                                             %
 334 %                                                                             %
 335 %   I s D P X                                                                 %
 336 %                                                                             %
 337 %                                                                             %
 338 %                                                                             %
 339 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 340 %
 341 %  IsDPX() returns MagickTrue if the image format type, identified by the
 342 %  magick string, is DPX.
 343 %
 344 %  The format of the IsDPX method is:
 345 %
 346 %      MagickBooleanType IsDPX(const unsigned char *magick,const size_t extent)
 347 %
 348 %  A description of each parameter follows:
 349 %
 350 %    o magick: compare image format pattern against these bytes.
 351 %
 352 %    o extent: Specifies the extent of the magick string.
 353 %
 354 */
 355 static MagickBooleanType IsDPX(const unsigned char *magick,const size_t extent)
 356 {
 357   if (extent < 4)
 358     return(MagickFalse);
 359   if (memcmp(magick,"SDPX",4) == 0)
 360     return(MagickTrue);
 361   if (memcmp(magick,"XPDS",4) == 0)
 362     return(MagickTrue);
 363   return(MagickFalse);
 364 }
 365 \f
 366 /*
 367 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 368 %                                                                             %
 369 %                                                                             %
 370 %                                                                             %
 371 %   R e a d D P X I m a g e                                                   %
 372 %                                                                             %
 373 %                                                                             %
 374 %                                                                             %
 375 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 376 %
 377 %  ReadDPXImage() reads an DPX X image file and returns it.  It
 378 %  allocates the memory necessary for the new Image structure and returns a
 379 %  pointer to the new image.
 380 %
 381 %  The format of the ReadDPXImage method is:
 382 %
 383 %      Image *ReadDPXImage(const ImageInfo *image_info,ExceptionInfo *exception)
 384 %
 385 %  A description of each parameter follows:
 386 %
 387 %    o image_info: the image info.
 388 %
 389 %    o exception: return any errors or warnings in this structure.
 390 %
 391 */
 392
 393 static size_t GetBytesPerRow(const size_t columns,
 394   const size_t samples_per_pixel,const size_t bits_per_pixel,
 395   const MagickBooleanType pad)
 396 {
 397   size_t
 398     bytes_per_row;
 399
 400   switch (bits_per_pixel)
 401   {
 402     case 1:
 403     {
 404       bytes_per_row=4*(((size_t) samples_per_pixel*columns*bits_per_pixel+31)/
 405         32);
 406       break;
 407     }
 408     case 8:
 409     default:
 410     {
 411       bytes_per_row=4*(((size_t) samples_per_pixel*columns*bits_per_pixel+31)/
 412         32);
 413       break;
 414     }
 415     case 10:
 416     {
 417       if (pad == MagickFalse)
 418         {
 419           bytes_per_row=4*(((size_t) samples_per_pixel*columns*bits_per_pixel+
 420             31)/32);
 421           break;
 422         }
 423       bytes_per_row=4*(((size_t) (32*((samples_per_pixel*columns+2)/3))+31)/32);
 424       break;
 425     }
 426     case 12:
 427     {
 428       if (pad == MagickFalse)
 429         {
 430           bytes_per_row=4*(((size_t) samples_per_pixel*columns*bits_per_pixel+
 431             31)/32);
 432           break;
 433         }
 434       bytes_per_row=2*(((size_t) (16*samples_per_pixel*columns)+15)/16);
 435       break;
 436     }
 437     case 16:
 438     {
 439       bytes_per_row=2*(((size_t) samples_per_pixel*columns*bits_per_pixel+8)/
 440         16);
 441       break;
 442     }
 443     case 32:
 444     {
 445       bytes_per_row=4*(((size_t) samples_per_pixel*columns*bits_per_pixel+31)/
 446         32);
 447       break;
 448     }
 449     case 64:
 450     {
 451       bytes_per_row=8*(((size_t) samples_per_pixel*columns*bits_per_pixel+63)/
 452         64);
 453       break;
 454     }
 455   }
 456   return(bytes_per_row);
 457 }
 458
 459 static const char *GetImageTransferCharacteristic(
 460   const DPXTransferCharacteristic characteristic)
 461 {
 462   const char
 463     *transfer;
 464
 465   /*
 466     Get the element transfer characteristic.
 467   */
 468   switch(characteristic)
 469   {
 470     case TransferCharacteristicUserDefined:
 471     {
 472       transfer="UserDefined";
 473       break;
 474     }
 475     case TransferCharacteristicPrintingDensity:
 476     {
 477       transfer="PrintingDensity";
 478       break;
 479     }
 480     case TransferCharacteristicLinear:
 481     {
 482       transfer="Linear";
 483       break;
 484     }
 485     case TransferCharacteristicLogarithmic:
 486     {
 487       transfer="Logarithmic";
 488       break;
 489     }
 490     case TransferCharacteristicUnspecifiedVideo:
 491     {
 492       transfer="UnspecifiedVideo";
 493       break;
 494     }
 495     case TransferCharacteristicSMTPE274M:
 496     {
 497       transfer="SMTPE274M";
 498       break;
 499     }
 500     case TransferCharacteristicITU_R709:
 501     {
 502       transfer="ITU-R709";
 503       break;
 504     }
 505     case TransferCharacteristicITU_R601_625L:
 506     {
 507       transfer="ITU-R601-625L";
 508       break;
 509     }
 510     case TransferCharacteristicITU_R601_525L:
 511     {
 512       transfer="ITU-R601-525L";
 513       break;
 514     }
 515     case TransferCharacteristicNTSCCompositeVideo:
 516     {
 517       transfer="NTSCCompositeVideo";
 518       break;
 519     }
 520     case TransferCharacteristicPALCompositeVideo:
 521     {
 522       transfer="PALCompositeVideo";
 523       break;
 524     }
 525     case TransferCharacteristicZDepthLinear:
 526     {
 527       transfer="ZDepthLinear";
 528       break;
 529     }
 530     case TransferCharacteristicZDepthHomogeneous:
 531     {
 532       transfer="ZDepthHomogeneous";
 533       break;
 534     }
 535     default:
 536       transfer="Reserved";
 537   }
 538   return(transfer);
 539 }
 540
 541 static inline MagickBooleanType IsFloatDefined(const float value)
 542 {
 543   union
 544   {
 545     unsigned int
 546       unsigned_value;
 547
 548     float
 549       float_value;
 550   } quantum;
 551
 552   quantum.unsigned_value=0U;
 553   quantum.float_value=(float) value;
 554   if (quantum.unsigned_value == 0U)
 555     return(MagickFalse);
 556   return(MagickTrue);
 557 }
 558
 559 static void SetPrimaryChromaticity(const DPXColorimetric colorimetric,
 560   ChromaticityInfo *chromaticity_info)
 561 {
 562   switch(colorimetric)
 563   {
 564     case SMTPE_274MColorimetric:
 565     case ITU_R709Colorimetric:
 566     {
 567       chromaticity_info->red_primary.x=0.640;
 568       chromaticity_info->red_primary.y=0.330;
 569       chromaticity_info->red_primary.z=0.030;
 570       chromaticity_info->green_primary.x=0.300;
 571       chromaticity_info->green_primary.y=0.600;
 572       chromaticity_info->green_primary.z=0.100;
 573       chromaticity_info->blue_primary.x=0.150;
 574       chromaticity_info->blue_primary.y=0.060;
 575       chromaticity_info->blue_primary.z=0.790;
 576       chromaticity_info->white_point.x=0.3127;
 577       chromaticity_info->white_point.y=0.3290;
 578       chromaticity_info->white_point.z=0.3582;
 579       break;
 580     }
 581     case NTSCCompositeVideoColorimetric:
 582     {
 583       chromaticity_info->red_primary.x=0.67;
 584       chromaticity_info->red_primary.y=0.33;
 585       chromaticity_info->red_primary.z=0.00;
 586       chromaticity_info->green_primary.x=0.21;
 587       chromaticity_info->green_primary.y=0.71;
 588       chromaticity_info->green_primary.z=0.08;
 589       chromaticity_info->blue_primary.x=0.14;
 590       chromaticity_info->blue_primary.y=0.08;
 591       chromaticity_info->blue_primary.z=0.78;
 592       chromaticity_info->white_point.x=0.310;
 593       chromaticity_info->white_point.y=0.316;
 594       chromaticity_info->white_point.z=0.374;
 595       break;
 596     }
 597     case PALCompositeVideoColorimetric:
 598     {
 599       chromaticity_info->red_primary.x=0.640;
 600       chromaticity_info->red_primary.y=0.330;
 601       chromaticity_info->red_primary.z=0.030;
 602       chromaticity_info->green_primary.x=0.290;
 603       chromaticity_info->green_primary.y=0.600;
 604       chromaticity_info->green_primary.z=0.110;
 605       chromaticity_info->blue_primary.x=0.150;
 606       chromaticity_info->blue_primary.y=0.060;
 607       chromaticity_info->blue_primary.z=0.790;
 608       chromaticity_info->white_point.x=0.3127;
 609       chromaticity_info->white_point.y=0.3290;
 610       chromaticity_info->white_point.z=0.3582;
 611       break;
 612     }
 613     default:
 614       break;
 615   }
 616 }
 617
 618 static void TimeCodeToString(const size_t timestamp,char *code)
 619 {
 620 #define TimeFields  7
 621
 622   unsigned int
 623     shift;
 624
 625   register ssize_t
 626     i;
 627
 628   *code='\0';
 629   shift=4*TimeFields;
 630   for (i=0; i <= TimeFields; i++)
 631   {
 632     (void) FormatLocaleString(code,MaxTextExtent-strlen(code),"%x",
 633       (unsigned int) ((timestamp >> shift) & 0x0fU));
 634     code++;
 635     if (((i % 2) != 0) && (i < TimeFields))
 636       *code++=':';
 637     shift-=4;
 638     *code='\0';
 639   }
 640 }
 641
 642 static Image *ReadDPXImage(const ImageInfo *image_info,ExceptionInfo *exception)
 643 {
 644   char
 645     magick[4],
 646     value[MaxTextExtent];
 647
 648   DPXInfo
 649     dpx;
 650
 651   Image
 652     *image;
 653
 654   MagickBooleanType
 655     status;
 656
 657   MagickOffsetType
 658     offset;
 659
 660   QuantumInfo
 661     *quantum_info;
 662
 663   QuantumType
 664     quantum_type;
 665
 666   register ssize_t
 667     i;
 668
 669   size_t
 670     extent,
 671     samples_per_pixel;
 672
 673   ssize_t
 674     count,
 675     n,
 676     row,
 677     y;
 678
 679   unsigned char
 680     component_type;
 681
 682   /*
 683     Open image file.
 684   */
 685   assert(image_info != (const ImageInfo *) NULL);
 686   assert(image_info->signature == MagickSignature);
 687   if (image_info->debug != MagickFalse)
 688     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 689       image_info->filename);
 690   assert(exception != (ExceptionInfo *) NULL);
 691   assert(exception->signature == MagickSignature);
 692   image=AcquireImage(image_info,exception);
 693   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 694   if (status == MagickFalse)
 695     {
 696       image=DestroyImageList(image);
 697       return((Image *) NULL);
 698     }
 699   /*
 700     Read DPX file header.
 701   */
 702   offset=0;
 703   count=ReadBlob(image,4,(unsigned char *) magick);
 704   offset+=count;
 705   if ((count != 4) || ((LocaleNCompare(magick,"SDPX",4) != 0) &&
 706       (LocaleNCompare((char *) magick,"XPDS",4) != 0)))
 707     ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 708   image->endian=LSBEndian;
 709   if (LocaleNCompare(magick,"SDPX",4) == 0)
 710     image->endian=MSBEndian;
 711   (void) ResetMagickMemory(&dpx,0,sizeof(dpx));
 712   dpx.file.image_offset=ReadBlobLong(image);
 713   offset+=4;
 714   offset+=ReadBlob(image,sizeof(dpx.file.version),(unsigned char *)
 715     dpx.file.version);
 716   (void) FormatImageProperty(image,"dpx:file.version","%.8s",dpx.file.version);
 717   dpx.file.file_size=ReadBlobLong(image);
 718   offset+=4;
 719   dpx.file.ditto_key=ReadBlobLong(image);
 720   offset+=4;
 721   if (dpx.file.ditto_key != ~0U)
 722     (void) FormatImageProperty(image,"dpx:file.ditto.key","%u",
 723       dpx.file.ditto_key);
 724   dpx.file.generic_size=ReadBlobLong(image);
 725   offset+=4;
 726   dpx.file.industry_size=ReadBlobLong(image);
 727   offset+=4;
 728   dpx.file.user_size=ReadBlobLong(image);
 729   offset+=4;
 730   offset+=ReadBlob(image,sizeof(dpx.file.filename),(unsigned char *)
 731     dpx.file.filename);
 732   (void) FormatImageProperty(image,"dpx:file.filename","%.100s",
 733     dpx.file.filename);
 734   (void) FormatImageProperty(image,"document","%.100s",dpx.file.filename);
 735   offset+=ReadBlob(image,sizeof(dpx.file.timestamp),(unsigned char *)
 736     dpx.file.timestamp);
 737   if (*dpx.file.timestamp != '\0')
 738     (void) FormatImageProperty(image,"dpx:file.timestamp","%.24s",
 739       dpx.file.timestamp);
 740   offset+=ReadBlob(image,sizeof(dpx.file.creator),(unsigned char *)
 741     dpx.file.creator);
 742   if (*dpx.file.creator != '\0')
 743     {
 744       (void) FormatImageProperty(image,"dpx:file.creator","%.100s",
 745         dpx.file.creator);
 746       (void) FormatImageProperty(image,"software","%.100s",dpx.file.creator);
 747     }
 748   offset+=ReadBlob(image,sizeof(dpx.file.project),(unsigned char *)
 749     dpx.file.project);
 750   if (*dpx.file.project != '\0')
 751     {
 752       (void) FormatImageProperty(image,"dpx:file.project","%.200s",
 753         dpx.file.project);
 754       (void) FormatImageProperty(image,"comment","%.100s",dpx.file.project);
 755     }
 756   offset+=ReadBlob(image,sizeof(dpx.file.copyright),(unsigned char *)
 757     dpx.file.copyright);
 758   if (*dpx.file.copyright != '\0')
 759     {
 760       (void) FormatImageProperty(image,"dpx:file.copyright","%.200s",
 761         dpx.file.copyright);
 762       (void) FormatImageProperty(image,"copyright","%.100s",
 763         dpx.file.copyright);
 764     }
 765   dpx.file.encrypt_key=ReadBlobLong(image);
 766   offset+=4;
 767   if (dpx.file.encrypt_key != ~0U)
 768     (void) FormatImageProperty(image,"dpx:file.encrypt_key","%u",
 769       dpx.file.encrypt_key);
 770   offset+=ReadBlob(image,sizeof(dpx.file.reserve),(unsigned char *)
 771     dpx.file.reserve);
 772   /*
 773     Read DPX image header.
 774   */
 775   dpx.image.orientation=ReadBlobShort(image);
 776   offset+=2;
 777   if (dpx.image.orientation != (unsigned short) ~0)
 778     (void) FormatImageProperty(image,"dpx:image.orientation","%d",
 779       dpx.image.orientation);
 780   switch (dpx.image.orientation)
 781   {
 782     default:
 783     case 0: image->orientation=TopLeftOrientation; break;
 784     case 1: image->orientation=TopRightOrientation; break;
 785     case 2: image->orientation=BottomLeftOrientation; break;
 786     case 3: image->orientation=BottomRightOrientation; break;
 787     case 4: image->orientation=LeftTopOrientation; break;
 788     case 5: image->orientation=RightTopOrientation; break;
 789     case 6: image->orientation=LeftBottomOrientation; break;
 790     case 7: image->orientation=RightBottomOrientation; break;
 791   }
 792   dpx.image.number_elements=ReadBlobShort(image);
 793   offset+=2;
 794   dpx.image.pixels_per_line=ReadBlobLong(image);
 795   offset+=4;
 796   image->columns=dpx.image.pixels_per_line;
 797   dpx.image.lines_per_element=ReadBlobLong(image);
 798   offset+=4;
 799   image->rows=dpx.image.lines_per_element;
 800   for (i=0; i < 8; i++)
 801   {
 802     char
 803       property[MaxTextExtent];
 804
 805     dpx.image.image_element[i].data_sign=ReadBlobLong(image);
 806     offset+=4;
 807     dpx.image.image_element[i].low_data=ReadBlobLong(image);
 808     offset+=4;
 809     dpx.image.image_element[i].low_quantity=ReadBlobFloat(image);
 810     offset+=4;
 811     dpx.image.image_element[i].high_data=ReadBlobLong(image);
 812     offset+=4;
 813     dpx.image.image_element[i].high_quantity=ReadBlobFloat(image);
 814     offset+=4;
 815     dpx.image.image_element[i].descriptor=(unsigned char) ReadBlobByte(image);
 816     offset++;
 817     dpx.image.image_element[i].transfer_characteristic=(unsigned char)
 818       ReadBlobByte(image);
 819     (void) FormatLocaleString(property,MaxTextExtent,
 820       "dpx:image.element[%lu].transfer-characteristic",(long) i);
 821     (void) FormatImageProperty(image,property,"%s",
 822       GetImageTransferCharacteristic((DPXTransferCharacteristic)
 823       dpx.image.image_element[i].transfer_characteristic));
 824     offset++;
 825     dpx.image.image_element[i].colorimetric=(unsigned char) ReadBlobByte(image);
 826     offset++;
 827     dpx.image.image_element[i].bit_size=(unsigned char) ReadBlobByte(image);
 828     offset++;
 829     dpx.image.image_element[i].packing=ReadBlobShort(image);
 830     offset+=2;
 831     dpx.image.image_element[i].encoding=ReadBlobShort(image);
 832     offset+=2;
 833     dpx.image.image_element[i].data_offset=ReadBlobLong(image);
 834     offset+=4;
 835     dpx.image.image_element[i].end_of_line_padding=ReadBlobLong(image);
 836     offset+=4;
 837     dpx.image.image_element[i].end_of_image_padding=ReadBlobLong(image);
 838     offset+=4;
 839     offset+=ReadBlob(image,sizeof(dpx.image.image_element[i].description),
 840       (unsigned char *) dpx.image.image_element[i].description);
 841   }
 842   SetImageColorspace(image,RGBColorspace,exception);
 843   offset+=ReadBlob(image,sizeof(dpx.image.reserve),(unsigned char *)
 844     dpx.image.reserve);
 845   if (dpx.file.image_offset >= 1664U)
 846     {
 847       /*
 848         Read DPX orientation header.
 849       */
 850       dpx.orientation.x_offset=ReadBlobLong(image);
 851       offset+=4;
 852       if (dpx.orientation.x_offset != ~0U)
 853         (void) FormatImageProperty(image,"dpx:orientation.x_offset","%u",
 854           dpx.orientation.x_offset);
 855       dpx.orientation.y_offset=ReadBlobLong(image);
 856       offset+=4;
 857       if (dpx.orientation.y_offset != ~0U)
 858         (void) FormatImageProperty(image,"dpx:orientation.y_offset","%u",
 859           dpx.orientation.y_offset);
 860       dpx.orientation.x_center=ReadBlobFloat(image);
 861       offset+=4;
 862       if (IsFloatDefined(dpx.orientation.x_center) != MagickFalse)
 863         (void) FormatImageProperty(image,"dpx:orientation.x_center","%g",
 864           dpx.orientation.x_center);
 865       dpx.orientation.y_center=ReadBlobFloat(image);
 866       offset+=4;
 867       if (IsFloatDefined(dpx.orientation.y_center) != MagickFalse)
 868         (void) FormatImageProperty(image,"dpx:orientation.y_center","%g",
 869           dpx.orientation.y_center);
 870       dpx.orientation.x_size=ReadBlobLong(image);
 871       offset+=4;
 872       if (dpx.orientation.x_size != ~0U)
 873         (void) FormatImageProperty(image,"dpx:orientation.x_size","%u",
 874           dpx.orientation.x_size);
 875       dpx.orientation.y_size=ReadBlobLong(image);
 876       offset+=4;
 877       if (dpx.orientation.y_size != ~0U)
 878         (void) FormatImageProperty(image,"dpx:orientation.y_size","%u",
 879           dpx.orientation.y_size);
 880       offset+=ReadBlob(image,sizeof(dpx.orientation.filename),(unsigned char *)
 881         dpx.orientation.filename);
 882       if (*dpx.orientation.filename != '\0')
 883         (void) FormatImageProperty(image,"dpx:orientation.filename","%.100s",
 884           dpx.orientation.filename);
 885       offset+=ReadBlob(image,sizeof(dpx.orientation.timestamp),(unsigned char *)
 886         dpx.orientation.timestamp);
 887       if (*dpx.orientation.timestamp != '\0')
 888         (void) FormatImageProperty(image,"dpx:orientation.timestamp","%.24s",
 889           dpx.orientation.timestamp);
 890       offset+=ReadBlob(image,sizeof(dpx.orientation.device),(unsigned char *)
 891         dpx.orientation.device);
 892       if (*dpx.orientation.device != '\0')
 893         (void) FormatImageProperty(image,"dpx:orientation.device","%.32s",
 894           dpx.orientation.device);
 895       offset+=ReadBlob(image,sizeof(dpx.orientation.serial),(unsigned char *)
 896         dpx.orientation.serial);
 897       if (*dpx.orientation.serial != '\0')
 898         (void) FormatImageProperty(image,"dpx:orientation.serial","%.32s",
 899           dpx.orientation.serial);
 900       for (i=0; i < 4; i++)
 901       {
 902         dpx.orientation.border[i]=ReadBlobShort(image);
 903         offset+=2;
 904       }
 905       if ((dpx.orientation.border[0] != (unsigned short) (~0)) &&
 906           (dpx.orientation.border[1] != (unsigned short) (~0)))
 907         (void) FormatImageProperty(image,"dpx:orientation.border","%dx%d%+d%+d",
 908           dpx.orientation.border[0],dpx.orientation.border[1],
 909           dpx.orientation.border[2],dpx.orientation.border[3]);
 910       for (i=0; i < 2; i++)
 911       {
 912         dpx.orientation.aspect_ratio[i]=ReadBlobLong(image);
 913         offset+=4;
 914       }
 915       if ((dpx.orientation.aspect_ratio[0] != ~0U) &&
 916           (dpx.orientation.aspect_ratio[1] != ~0U))
 917         (void) FormatImageProperty(image,"dpx:orientation.aspect_ratio",
 918           "%ux%u",dpx.orientation.aspect_ratio[0],
 919           dpx.orientation.aspect_ratio[1]);
 920       offset+=ReadBlob(image,sizeof(dpx.orientation.reserve),(unsigned char *)
 921         dpx.orientation.reserve);
 922     }
 923   if (dpx.file.image_offset >= 1920U)
 924     {
 925       /*
 926         Read DPX film header.
 927       */
 928       offset+=ReadBlob(image,sizeof(dpx.film.id),(unsigned char *) dpx.film.id);
 929       if (*dpx.film.type != '\0')
 930         (void) FormatImageProperty(image,"dpx:film.id","%.2s",dpx.film.id);
 931       offset+=ReadBlob(image,sizeof(dpx.film.type),(unsigned char *)
 932         dpx.film.type);
 933       if (*dpx.film.type != '\0')
 934         (void) FormatImageProperty(image,"dpx:film.type","%.2s",dpx.film.type);
 935       offset+=ReadBlob(image,sizeof(dpx.film.offset),(unsigned char *)
 936         dpx.film.offset);
 937       if (*dpx.film.offset != '\0')
 938         (void) FormatImageProperty(image,"dpx:film.offset","%.2s",
 939           dpx.film.offset);
 940       offset+=ReadBlob(image,sizeof(dpx.film.prefix),(unsigned char *)
 941         dpx.film.prefix);
 942       if (*dpx.film.prefix != '\0')
 943         (void) FormatImageProperty(image,"dpx:film.prefix","%.6s",
 944           dpx.film.prefix);
 945       offset+=ReadBlob(image,sizeof(dpx.film.count),(unsigned char *)
 946         dpx.film.count);
 947       if (*dpx.film.count != '\0')
 948         (void) FormatImageProperty(image,"dpx:film.count","%.4s",
 949           dpx.film.count);
 950       offset+=ReadBlob(image,sizeof(dpx.film.format),(unsigned char *)
 951         dpx.film.format);
 952       if (*dpx.film.format != '\0')
 953         (void) FormatImageProperty(image,"dpx:film.format","%.4s",
 954           dpx.film.format);
 955       dpx.film.frame_position=ReadBlobLong(image);
 956       offset+=4;
 957       if (dpx.film.frame_position != ~0U)
 958         (void) FormatImageProperty(image,"dpx:film.frame_position","%u",
 959           dpx.film.frame_position);
 960       dpx.film.sequence_extent=ReadBlobLong(image);
 961       offset+=4;
 962       if (dpx.film.sequence_extent != ~0U)
 963         (void) FormatImageProperty(image,"dpx:film.sequence_extent","%u",
 964           dpx.film.sequence_extent);
 965       dpx.film.held_count=ReadBlobLong(image);
 966       offset+=4;
 967       if (dpx.film.held_count != ~0U)
 968         (void) FormatImageProperty(image,"dpx:film.held_count","%u",
 969           dpx.film.held_count);
 970       dpx.film.frame_rate=ReadBlobFloat(image);
 971       offset+=4;
 972       if (IsFloatDefined(dpx.film.frame_rate) != MagickFalse)
 973         (void) FormatImageProperty(image,"dpx:film.frame_rate","%g",
 974           dpx.film.frame_rate);
 975       dpx.film.shutter_angle=ReadBlobFloat(image);
 976       offset+=4;
 977       if (IsFloatDefined(dpx.film.shutter_angle) != MagickFalse)
 978         (void) FormatImageProperty(image,"dpx:film.shutter_angle","%g",
 979           dpx.film.shutter_angle);
 980       offset+=ReadBlob(image,sizeof(dpx.film.frame_id),(unsigned char *)
 981         dpx.film.frame_id);
 982       if (*dpx.film.frame_id != '\0')
 983         (void) FormatImageProperty(image,"dpx:film.frame_id","%.32s",
 984           dpx.film.frame_id);
 985       offset+=ReadBlob(image,sizeof(dpx.film.slate),(unsigned char *)
 986         dpx.film.slate);
 987       if (*dpx.film.slate != '\0')
 988         (void) FormatImageProperty(image,"dpx:film.slate","%.100s",
 989           dpx.film.slate);
 990       offset+=ReadBlob(image,sizeof(dpx.film.reserve),(unsigned char *)
 991         dpx.film.reserve);
 992     }
 993   if (dpx.file.image_offset >= 2048U)
 994     {
 995       /*
 996         Read DPX television header.
 997       */
 998       dpx.television.time_code=(unsigned int) ReadBlobLong(image);
 999       offset+=4;
1000       TimeCodeToString(dpx.television.time_code,value);
1001       (void) SetImageProperty(image,"dpx:television.time.code",value,exception);
1002       dpx.television.user_bits=(unsigned int) ReadBlobLong(image);
1003       offset+=4;
1004       TimeCodeToString(dpx.television.user_bits,value);
1005       (void) SetImageProperty(image,"dpx:television.user.bits",value,exception);
1006       dpx.television.interlace=(unsigned char) ReadBlobByte(image);
1007       offset++;
1008       if (dpx.television.interlace != 0)
1009         (void) FormatImageProperty(image,"dpx:television.interlace","%.20g",
1010           (double) dpx.television.interlace);
1011       dpx.television.field_number=(unsigned char) ReadBlobByte(image);
1012       offset++;
1013       if (dpx.television.field_number != 0)
1014         (void) FormatImageProperty(image,"dpx:television.field_number","%.20g",
1015           (double) dpx.television.field_number);
1016       dpx.television.video_signal=(unsigned char) ReadBlobByte(image);
1017       offset++;
1018       if (dpx.television.video_signal != 0)
1019         (void) FormatImageProperty(image,"dpx:television.video_signal","%.20g",
1020           (double) dpx.television.video_signal);
1021       dpx.television.padding=(unsigned char) ReadBlobByte(image);
1022       offset++;
1023       if (dpx.television.padding != 0)
1024         (void) FormatImageProperty(image,"dpx:television.padding","%d",
1025           dpx.television.padding);
1026       dpx.television.horizontal_sample_rate=ReadBlobFloat(image);
1027       offset+=4;
1028       if (IsFloatDefined(dpx.television.horizontal_sample_rate) != MagickFalse)
1029         (void) FormatImageProperty(image,
1030           "dpx:television.horizontal_sample_rate","%g",
1031           dpx.television.horizontal_sample_rate);
1032       dpx.television.vertical_sample_rate=ReadBlobFloat(image);
1033       offset+=4;
1034       if (IsFloatDefined(dpx.television.vertical_sample_rate) != MagickFalse)
1035         (void) FormatImageProperty(image,"dpx:television.vertical_sample_rate",
1036           "%g",dpx.television.vertical_sample_rate);
1037       dpx.television.frame_rate=ReadBlobFloat(image);
1038       offset+=4;
1039       if (IsFloatDefined(dpx.television.frame_rate) != MagickFalse)
1040         (void) FormatImageProperty(image,"dpx:television.frame_rate","%g",
1041           dpx.television.frame_rate);
1042       dpx.television.time_offset=ReadBlobFloat(image);
1043       offset+=4;
1044       if (IsFloatDefined(dpx.television.time_offset) != MagickFalse)
1045         (void) FormatImageProperty(image,"dpx:television.time_offset","%g",
1046           dpx.television.time_offset);
1047       dpx.television.gamma=ReadBlobFloat(image);
1048       offset+=4;
1049       if (IsFloatDefined(dpx.television.gamma) != MagickFalse)
1050         (void) FormatImageProperty(image,"dpx:television.gamma","%g",
1051           dpx.television.gamma);
1052       dpx.television.black_level=ReadBlobFloat(image);
1053       offset+=4;
1054       if (IsFloatDefined(dpx.television.black_level) != MagickFalse)
1055         (void) FormatImageProperty(image,"dpx:television.black_level","%g",
1056           dpx.television.black_level);
1057       dpx.television.black_gain=ReadBlobFloat(image);
1058       offset+=4;
1059       if (IsFloatDefined(dpx.television.black_gain) != MagickFalse)
1060         (void) FormatImageProperty(image,"dpx:television.black_gain","%g",
1061           dpx.television.black_gain);
1062       dpx.television.break_point=ReadBlobFloat(image);
1063       offset+=4;
1064       if (IsFloatDefined(dpx.television.break_point) != MagickFalse)
1065         (void) FormatImageProperty(image,"dpx:television.break_point","%g",
1066           dpx.television.break_point);
1067       dpx.television.white_level=ReadBlobFloat(image);
1068       offset+=4;
1069       if (IsFloatDefined(dpx.television.white_level) != MagickFalse)
1070         (void) FormatImageProperty(image,"dpx:television.white_level","%g",
1071           dpx.television.white_level);
1072       dpx.television.integration_times=ReadBlobFloat(image);
1073       offset+=4;
1074       if (IsFloatDefined(dpx.television.integration_times) != MagickFalse)
1075         (void) FormatImageProperty(image,"dpx:television.integration_times",
1076           "%g",dpx.television.integration_times);
1077       offset+=ReadBlob(image,sizeof(dpx.television.reserve),(unsigned char *)
1078         dpx.television.reserve);
1079     }
1080   if (dpx.file.image_offset > 2080U)
1081     {
1082       /*
1083         Read DPX user header.
1084       */
1085       offset+=ReadBlob(image,sizeof(dpx.user.id),(unsigned char *) dpx.user.id);
1086       if (*dpx.user.id != '\0')
1087         (void) FormatImageProperty(image,"dpx:user.id","%.32s",dpx.user.id);
1088       if ((dpx.file.user_size != ~0U) &&
1089           ((size_t) dpx.file.user_size > sizeof(dpx.user.id)))
1090         {
1091           StringInfo
1092             *profile;
1093
1094            profile=BlobToStringInfo((const void *) NULL,
1095              dpx.file.user_size-sizeof(dpx.user.id));
1096            if (profile == (StringInfo *) NULL)
1097              ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1098            offset+=ReadBlob(image,GetStringInfoLength(profile),
1099              GetStringInfoDatum(profile));
1100            (void) SetImageProfile(image,"dpx:user-data",profile,exception);
1101            profile=DestroyStringInfo(profile);
1102         }
1103     }
1104   for ( ; offset < (MagickOffsetType) dpx.file.image_offset; offset++)
1105     (void) ReadBlobByte(image);
1106   if (image_info->ping != MagickFalse)
1107     {
1108       (void) CloseBlob(image);
1109       return(GetFirstImageInList(image));
1110     }
1111   for (n=0; n < (ssize_t) dpx.image.number_elements; n++)
1112   {
1113     /*
1114       Convert DPX raster image to pixel packets.
1115     */
1116     if ((dpx.image.image_element[n].data_offset != ~0U) &&
1117         (dpx.image.image_element[n].data_offset != 0U))
1118       {
1119          MagickOffsetType
1120            data_offset;
1121
1122          data_offset=(MagickOffsetType) dpx.image.image_element[n].data_offset;
1123          if (data_offset < offset)
1124            offset=SeekBlob(image,data_offset,SEEK_SET);
1125          else
1126            for ( ; offset < data_offset; offset++)
1127              (void) ReadBlobByte(image);
1128           if (offset != data_offset)
1129             ThrowReaderException(CorruptImageError,"UnableToReadImageData");
1130        }
1131     SetPrimaryChromaticity((DPXColorimetric)
1132       dpx.image.image_element[n].colorimetric,&image->chromaticity);
1133     image->depth=dpx.image.image_element[n].bit_size;
1134     samples_per_pixel=1;
1135     quantum_type=GrayQuantum;
1136     component_type=dpx.image.image_element[n].descriptor;
1137     switch (component_type)
1138     {
1139       case CbYCrY422ComponentType:
1140       {
1141         samples_per_pixel=2;
1142         quantum_type=CbYCrYQuantum;
1143         break;
1144       }
1145       case CbYACrYA4224ComponentType:
1146       case CbYCr444ComponentType:
1147       {
1148         samples_per_pixel=3;
1149         quantum_type=CbYCrQuantum;
1150         break;
1151       }
1152       case RGBComponentType:
1153       {
1154         samples_per_pixel=3;
1155         quantum_type=RGBQuantum;
1156         break;
1157       }
1158       case ABGRComponentType:
1159       case RGBAComponentType:
1160       {
1161         image->alpha_trait=BlendPixelTrait;
1162         samples_per_pixel=4;
1163         quantum_type=RGBAQuantum;
1164         break;
1165       }
1166       default:
1167         break;
1168     }
1169     switch (component_type)
1170     {
1171       case CbYCrY422ComponentType:
1172       case CbYACrYA4224ComponentType:
1173       case CbYCr444ComponentType:
1174       {
1175         SetImageColorspace(image,Rec709YCbCrColorspace,exception);
1176         break;
1177       }
1178       case LumaComponentType:
1179       {
1180         SetImageColorspace(image,GRAYColorspace,exception);
1181         break;
1182       }
1183       default:
1184       {
1185         SetImageColorspace(image,sRGBColorspace,exception);
1186         if (dpx.image.image_element[n].transfer_characteristic == LogarithmicColorimetric)
1187           SetImageColorspace(image,LogColorspace,exception);
1188         if (dpx.image.image_element[n].transfer_characteristic == PrintingDensityColorimetric)
1189           SetImageColorspace(image,LogColorspace,exception);
1190         break;
1191       }
1192     }
1193     extent=GetBytesPerRow(image->columns,samples_per_pixel,image->depth,
1194       dpx.image.image_element[n].packing == 0 ? MagickFalse : MagickTrue);
1195     /*
1196       DPX any-bit pixel format.
1197     */
1198     status=MagickTrue;
1199     row=0;
1200     quantum_info=AcquireQuantumInfo(image_info,image);
1201     if (quantum_info == (QuantumInfo *) NULL)
1202       ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
1203     SetQuantumQuantum(quantum_info,32);
1204     SetQuantumPack(quantum_info,dpx.image.image_element[n].packing == 0 ?
1205       MagickTrue : MagickFalse);
1206     for (y=0; y < (ssize_t) image->rows; y++)
1207     {
1208       MagickBooleanType
1209         sync;
1210
1211       register Quantum
1212         *q;
1213
1214       size_t
1215         length;
1216
1217       ssize_t
1218         count,
1219         offset;
1220
1221       unsigned char
1222         *pixels;
1223
1224       if (status == MagickFalse)
1225         continue;
1226       pixels=GetQuantumPixels(quantum_info);
1227       {
1228         count=ReadBlob(image,extent,pixels);
1229         if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&
1230             (image->previous == (Image *) NULL))
1231           {
1232             MagickBooleanType
1233               proceed;
1234
1235             proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType) row,
1236               image->rows);
1237             if (proceed == MagickFalse)
1238               status=MagickFalse;
1239           }
1240         offset=row++;
1241       }
1242       if (count != (ssize_t) extent)
1243         status=MagickFalse;
1244       q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);
1245       if (q == (Quantum *) NULL)
1246         {
1247           status=MagickFalse;
1248           continue;
1249         }
1250       length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1251         quantum_type,pixels,exception);
1252       (void) length;
1253       sync=SyncAuthenticPixels(image,exception);
1254       if (sync == MagickFalse)
1255         status=MagickFalse;
1256     }
1257     quantum_info=DestroyQuantumInfo(quantum_info);
1258     if (status == MagickFalse)
1259       ThrowReaderException(CorruptImageError,"UnableToReadImageData");
1260     SetQuantumImageType(image,quantum_type);
1261     if (EOFBlob(image) != MagickFalse)
1262       ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
1263         image->filename);
1264     if ((i+1) < (ssize_t) dpx.image.number_elements)
1265       {
1266         /*
1267           Allocate next image structure.
1268         */
1269         AcquireNextImage(image_info,image,exception);
1270         if (GetNextImageInList(image) == (Image *) NULL)
1271           {
1272             image=DestroyImageList(image);
1273             return((Image *) NULL);
1274           }
1275         image=SyncNextImageInList(image);
1276         status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
1277           GetBlobSize(image));
1278         if (status == MagickFalse)
1279           break;
1280       }
1281   }
1282   (void) CloseBlob(image);
1283   return(GetFirstImageInList(image));
1284 }
1285 \f
1286 /*
1287 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1288 %                                                                             %
1289 %                                                                             %
1290 %                                                                             %
1291 %   R e g i s t e r D P X I m a g e                                           %
1292 %                                                                             %
1293 %                                                                             %
1294 %                                                                             %
1295 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1296 %
1297 %  RegisterDPXImage() adds properties for the DPX image format to
1298 %  the list of supported formats.  The properties include the image format
1299 %  tag, a method to read and/or write the format, whether the format
1300 %  supports the saving of more than one frame to the same file or blob,
1301 %  whether the format supports native in-memory I/O, and a brief
1302 %  description of the format.
1303 %
1304 %  The format of the RegisterDPXImage method is:
1305 %
1306 %      size_t RegisterDPXImage(void)
1307 %
1308 */
1309 ModuleExport size_t RegisterDPXImage(void)
1310 {
1311   MagickInfo
1312     *entry;
1313
1314   static const char
1315     *DPXNote =
1316     {
1317       "Digital Moving Picture Exchange Bitmap, Version 2.0.\n"
1318       "See SMPTE 268M-2003 specification at http://www.smtpe.org\n"
1319     };
1320
1321   entry=SetMagickInfo("DPX");
1322   entry->decoder=(DecodeImageHandler *) ReadDPXImage;
1323   entry->encoder=(EncodeImageHandler *) WriteDPXImage;
1324   entry->magick=(IsImageFormatHandler *) IsDPX;
1325   entry->adjoin=MagickFalse;
1326   entry->seekable_stream=MagickTrue;
1327   entry->description=ConstantString("SMPTE 268M-2003 (DPX 2.0)");
1328   entry->note=ConstantString(DPXNote);
1329   entry->module=ConstantString("DPX");
1330   (void) RegisterMagickInfo(entry);
1331   return(MagickImageCoderSignature);
1332 }
1333 \f
1334 /*
1335 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1336 %                                                                             %
1337 %                                                                             %
1338 %                                                                             %
1339 %   U n r e g i s t e r D P X I m a g e                                       %
1340 %                                                                             %
1341 %                                                                             %
1342 %                                                                             %
1343 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1344 %
1345 %  UnregisterDPXImage() removes format registrations made by the
1346 %  DPX module from the list of supported formats.
1347 %
1348 %  The format of the UnregisterDPXImage method is:
1349 %
1350 %      UnregisterDPXImage(void)
1351 %
1352 */
1353 ModuleExport void UnregisterDPXImage(void)
1354 {
1355   (void) UnregisterMagickInfo("DPX");
1356 }
1357 \f
1358 /*
1359 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1360 %                                                                             %
1361 %                                                                             %
1362 %                                                                             %
1363 %   W r i t e D P X I m a g e                                                 %
1364 %                                                                             %
1365 %                                                                             %
1366 %                                                                             %
1367 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1368 %
1369 %  WriteDPXImage() writes an image in DPX encoded image format.
1370 %
1371 %  The format of the WriteDPXImage method is:
1372 %
1373 %      MagickBooleanType WriteDPXImage(const ImageInfo *image_info,
1374 %        Image *image,ExceptionInfo *exception)
1375 %
1376 %  A description of each parameter follows.
1377 %
1378 %    o image_info: the image info.
1379 %
1380 %    o image:  The image.
1381 %
1382 %    o exception: return any errors or warnings in this structure.
1383 %
1384 */
1385
1386 static unsigned int StringToTimeCode(const char *key)
1387 {
1388   char
1389     buffer[2];
1390
1391   register ssize_t
1392     i;
1393
1394   unsigned int
1395     shift,
1396     value;
1397
1398   value=0;
1399   shift=28;
1400   buffer[1]='\0';
1401   for (i=0; (*key != 0) && (i < 11); i++)
1402   {
1403     if (isxdigit((int) ((unsigned char) *key)) == 0)
1404       {
1405         key++;
1406         continue;
1407       }
1408     buffer[0]=(*key++);
1409     value|=(unsigned int) ((strtol(buffer,(char **) NULL,16)) << shift);
1410     shift-=4;
1411   }
1412   return(value);
1413 }
1414
1415 static MagickBooleanType WriteDPXImage(const ImageInfo *image_info,Image *image,
1416   ExceptionInfo *exception)
1417 {
1418   const char
1419     *value;
1420
1421   const StringInfo
1422     *profile;
1423
1424   DPXInfo
1425     dpx;
1426
1427   GeometryInfo
1428     geometry_info;
1429
1430   MagickBooleanType
1431     status;
1432
1433   MagickOffsetType
1434     offset;
1435
1436   MagickStatusType
1437     flags;
1438
1439   QuantumInfo
1440     *quantum_info;
1441
1442   QuantumType
1443     quantum_type;
1444
1445   register const Quantum
1446     *p;
1447
1448   register ssize_t
1449     i;
1450
1451   size_t
1452     extent;
1453
1454   ssize_t
1455     count,
1456     horizontal_factor,
1457     vertical_factor,
1458     y;
1459
1460   time_t
1461     seconds;
1462
1463   unsigned char
1464     *pixels;
1465
1466   /*
1467     Open output image file.
1468   */
1469   assert(image_info != (const ImageInfo *) NULL);
1470   assert(image_info->signature == MagickSignature);
1471   assert(image != (Image *) NULL);
1472   assert(image->signature == MagickSignature);
1473   if (image->debug != MagickFalse)
1474     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1475   horizontal_factor=4;
1476   vertical_factor=4;
1477   if (image_info->sampling_factor != (char *) NULL)
1478     {
1479       GeometryInfo
1480         geometry_info;
1481
1482       MagickStatusType
1483         flags;
1484
1485       flags=ParseGeometry(image_info->sampling_factor,&geometry_info);
1486       horizontal_factor=(ssize_t) geometry_info.rho;
1487       vertical_factor=(ssize_t) geometry_info.sigma;
1488       if ((flags & SigmaValue) == 0)
1489         vertical_factor=horizontal_factor;
1490       if ((horizontal_factor != 1) && (horizontal_factor != 2) &&
1491           (horizontal_factor != 4) && (vertical_factor != 1) &&
1492           (vertical_factor != 2) && (vertical_factor != 4))
1493         ThrowWriterException(CorruptImageError,"UnexpectedSamplingFactor");
1494     }
1495   if ((image->colorspace == YCbCrColorspace) &&
1496       ((horizontal_factor == 2) || (vertical_factor == 2)))
1497     if ((image->columns % 2) != 0)
1498       image->columns++;
1499   assert(exception != (ExceptionInfo *) NULL);
1500   assert(exception->signature == MagickSignature);
1501   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1502   if (status == MagickFalse)
1503     return(status);
1504   /*
1505     Write file header.
1506   */
1507   (void) ResetMagickMemory(&dpx,0,sizeof(dpx));
1508   offset=0;
1509   dpx.file.magic=0x53445058U;
1510   offset+=WriteBlobLong(image,dpx.file.magic);
1511   dpx.file.image_offset=0x2000U;
1512   profile=GetImageProfile(image,"dpx:user-data");
1513   if (profile != (StringInfo *) NULL)
1514     {
1515       if (GetStringInfoLength(profile) > 1048576)
1516         ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
1517       dpx.file.image_offset+=(unsigned int) GetStringInfoLength(profile);
1518       dpx.file.image_offset=(((dpx.file.image_offset+0x2000-1)/0x2000)*0x2000);
1519     }
1520   offset+=WriteBlobLong(image,dpx.file.image_offset);
1521   (void) strncpy(dpx.file.version,"V2.0",sizeof(dpx.file.version));
1522   offset+=WriteBlob(image,8,(unsigned char *) &dpx.file.version);
1523   dpx.file.file_size=(unsigned int) (4U*image->columns*image->rows+
1524     dpx.file.image_offset);
1525   offset+=WriteBlobLong(image,dpx.file.file_size);
1526   dpx.file.ditto_key=1U;  /* new frame */
1527   offset+=WriteBlobLong(image,dpx.file.ditto_key);
1528   dpx.file.generic_size=0x00000680U;
1529   offset+=WriteBlobLong(image,dpx.file.generic_size);
1530   dpx.file.industry_size=0x00000180U;
1531   offset+=WriteBlobLong(image,dpx.file.industry_size);
1532   dpx.file.user_size=0;
1533   if (profile != (StringInfo *) NULL)
1534     {
1535       dpx.file.user_size+=(unsigned int) GetStringInfoLength(profile);
1536       dpx.file.user_size=(((dpx.file.user_size+0x2000-1)/0x2000)*0x2000);
1537     }
1538   offset+=WriteBlobLong(image,dpx.file.user_size);
1539   value=GetImageArtifact(image,"dpx:file.filename");
1540   if (value != (const char *) NULL)
1541     (void) strncpy(dpx.file.filename,value,sizeof(dpx.file.filename));
1542   offset+=WriteBlob(image,sizeof(dpx.file.filename),(unsigned char *)
1543     dpx.file.filename);
1544   seconds=time((time_t *) NULL);
1545   (void) FormatMagickTime(seconds,sizeof(dpx.file.timestamp),
1546     dpx.file.timestamp);
1547   offset+=WriteBlob(image,sizeof(dpx.file.timestamp),(unsigned char *)
1548     dpx.file.timestamp);
1549   (void) strncpy(dpx.file.creator,GetMagickVersion((size_t *) NULL),
1550     sizeof(dpx.file.creator));
1551   value=GetImageArtifact(image,"dpx:file.creator");
1552   if (value != (const char *) NULL)
1553     (void) strncpy(dpx.file.creator,value,sizeof(dpx.file.creator));
1554   offset+=WriteBlob(image,sizeof(dpx.file.creator),(unsigned char *)
1555     dpx.file.creator);
1556   value=GetImageArtifact(image,"dpx:file.project");
1557   if (value != (const char *) NULL)
1558     (void) strncpy(dpx.file.project,value,sizeof(dpx.file.project));
1559   offset+=WriteBlob(image,sizeof(dpx.file.project),(unsigned char *)
1560     dpx.file.project);
1561   value=GetImageArtifact(image,"dpx:file.copyright");
1562   if (value != (const char *) NULL)
1563     (void) strncpy(dpx.file.copyright,value,sizeof(dpx.file.copyright));
1564   offset+=WriteBlob(image,sizeof(dpx.file.copyright),(unsigned char *)
1565     dpx.file.copyright);
1566   dpx.file.encrypt_key=(~0U);
1567   offset+=WriteBlobLong(image,dpx.file.encrypt_key);
1568   offset+=WriteBlob(image,sizeof(dpx.file.reserve),(unsigned char *)
1569     dpx.file.reserve);
1570   /*
1571     Write image header.
1572   */
1573   switch (image->orientation)
1574   {
1575     default:
1576     case TopLeftOrientation: dpx.image.orientation=0; break;
1577     case TopRightOrientation: dpx.image.orientation=1; break;
1578     case BottomLeftOrientation: dpx.image.orientation=2; break;
1579     case BottomRightOrientation: dpx.image.orientation=3; break;
1580     case LeftTopOrientation: dpx.image.orientation=4; break;
1581     case RightTopOrientation: dpx.image.orientation=5; break;
1582     case LeftBottomOrientation: dpx.image.orientation=6; break;
1583     case RightBottomOrientation: dpx.image.orientation=7; break;
1584   }
1585   offset+=WriteBlobShort(image,dpx.image.orientation);
1586   dpx.image.number_elements=1;
1587   offset+=WriteBlobShort(image,dpx.image.number_elements);
1588   if ((image->columns != (unsigned int) image->columns) ||
1589       (image->rows != (unsigned int) image->rows))
1590     ThrowWriterException(ImageError,"WidthOrHeightExceedsLimit");
1591   offset+=WriteBlobLong(image,(unsigned int) image->columns);
1592   offset+=WriteBlobLong(image,(unsigned int) image->rows);
1593   for (i=0; i < 8; i++)
1594   {
1595     dpx.image.image_element[i].data_sign=0U;
1596     offset+=WriteBlobLong(image,dpx.image.image_element[i].data_sign);
1597     dpx.image.image_element[i].low_data=0U;
1598     offset+=WriteBlobLong(image,dpx.image.image_element[i].low_data);
1599     dpx.image.image_element[i].low_quantity=0.0f;
1600     offset+=WriteBlobFloat(image,dpx.image.image_element[i].low_quantity);
1601     dpx.image.image_element[i].high_data=0U;
1602     offset+=WriteBlobLong(image,dpx.image.image_element[i].high_data);
1603     dpx.image.image_element[i].high_quantity=0.0f;
1604     offset+=WriteBlobFloat(image,dpx.image.image_element[i].high_quantity);
1605     dpx.image.image_element[i].descriptor=0;
1606     if (i == 0)
1607       switch (image->colorspace)
1608       {
1609         case Rec601YCbCrColorspace:
1610         case Rec709YCbCrColorspace:
1611         case YCbCrColorspace:
1612         {
1613           dpx.image.image_element[i].descriptor=CbYCr444ComponentType;
1614           if (image->alpha_trait == BlendPixelTrait)
1615             dpx.image.image_element[i].descriptor=CbYCrA4444ComponentType;
1616           break;
1617         }
1618         default:
1619         {
1620           dpx.image.image_element[i].descriptor=RGBComponentType;
1621           if (image->alpha_trait == BlendPixelTrait)
1622             dpx.image.image_element[i].descriptor=RGBAComponentType;
1623           if ((image_info->type != TrueColorType) &&
1624               (image->alpha_trait != BlendPixelTrait) &&
1625               (IsImageGray(image,exception) != MagickFalse))
1626             dpx.image.image_element[i].descriptor=LumaComponentType;
1627           break;
1628         }
1629       }
1630     offset+=WriteBlobByte(image,dpx.image.image_element[i].descriptor);
1631     dpx.image.image_element[i].transfer_characteristic=0;
1632     if (image->colorspace == LogColorspace)
1633       dpx.image.image_element[0].transfer_characteristic=
1634         PrintingDensityColorimetric;
1635     offset+=WriteBlobByte(image,
1636       dpx.image.image_element[i].transfer_characteristic);
1637     dpx.image.image_element[i].colorimetric=0;
1638     offset+=WriteBlobByte(image,dpx.image.image_element[i].colorimetric);
1639     dpx.image.image_element[i].bit_size=0;
1640     if (i == 0)
1641       dpx.image.image_element[i].bit_size=(unsigned char) image->depth;
1642     offset+=WriteBlobByte(image,dpx.image.image_element[i].bit_size);
1643     dpx.image.image_element[i].packing=0;
1644     if ((image->depth == 10) || (image->depth == 12))
1645       dpx.image.image_element[i].packing=1;
1646     offset+=WriteBlobShort(image,dpx.image.image_element[i].packing);
1647     dpx.image.image_element[i].encoding=0;
1648     offset+=WriteBlobShort(image,dpx.image.image_element[i].encoding);
1649     dpx.image.image_element[i].data_offset=0U;
1650     if (i == 0)
1651       dpx.image.image_element[i].data_offset=dpx.file.image_offset;
1652     offset+=WriteBlobLong(image,dpx.image.image_element[i].data_offset);
1653     dpx.image.image_element[i].end_of_line_padding=0U;
1654     offset+=WriteBlobLong(image,dpx.image.image_element[i].end_of_line_padding);
1655     offset+=WriteBlobLong(image,
1656       dpx.image.image_element[i].end_of_image_padding);
1657     offset+=WriteBlob(image,sizeof(dpx.image.image_element[i].description),
1658       (unsigned char *) dpx.image.image_element[i].description);
1659   }
1660   offset+=WriteBlob(image,sizeof(dpx.image.reserve),(unsigned char *)
1661     dpx.image.reserve);
1662   /*
1663     Write orientation header.
1664   */
1665   if ((image->rows != image->magick_rows) ||
1666       (image->columns != image->magick_columns))
1667     {
1668       /*
1669         These properties are not valid if image size changed.
1670       */
1671       (void) DeleteImageProperty(image,"dpx:orientation.x_offset");
1672       (void) DeleteImageProperty(image,"dpx:orientation.y_offset");
1673       (void) DeleteImageProperty(image,"dpx:orientation.x_center");
1674       (void) DeleteImageProperty(image,"dpx:orientation.y_center");
1675       (void) DeleteImageProperty(image,"dpx:orientation.x_size");
1676       (void) DeleteImageProperty(image,"dpx:orientation.y_size");
1677     }
1678   dpx.orientation.x_offset=0U;
1679   value=GetImageArtifact(image,"dpx:orientation.x_offset");
1680   if (value != (const char *) NULL)
1681     dpx.orientation.x_offset=(unsigned int) StringToUnsignedLong(value);
1682   offset+=WriteBlobLong(image,dpx.orientation.x_offset);
1683   dpx.orientation.y_offset=0U;
1684   value=GetImageArtifact(image,"dpx:orientation.y_offset");
1685   if (value != (const char *) NULL)
1686     dpx.orientation.y_offset=(unsigned int) StringToUnsignedLong(value);
1687   offset+=WriteBlobLong(image,dpx.orientation.y_offset);
1688   dpx.orientation.x_center=0.0f;
1689   value=GetImageArtifact(image,"dpx:orientation.x_center");
1690   if (value != (const char *) NULL)
1691     dpx.orientation.x_center=StringToDouble(value,(char **) NULL);
1692   offset+=WriteBlobFloat(image,dpx.orientation.x_center);
1693   dpx.orientation.y_center=0.0f;
1694   value=GetImageArtifact(image,"dpx:orientation.y_center");
1695   if (value != (const char *) NULL)
1696     dpx.orientation.y_center=StringToDouble(value,(char **) NULL);
1697   offset+=WriteBlobFloat(image,dpx.orientation.y_center);
1698   dpx.orientation.x_size=0U;
1699   value=GetImageArtifact(image,"dpx:orientation.x_size");
1700   if (value != (const char *) NULL)
1701     dpx.orientation.x_size=(unsigned int) StringToUnsignedLong(value);
1702   offset+=WriteBlobLong(image,dpx.orientation.x_size);
1703   dpx.orientation.y_size=0U;
1704   value=GetImageArtifact(image,"dpx:orientation.y_size");
1705   if (value != (const char *) NULL)
1706     dpx.orientation.y_size=(unsigned int) StringToUnsignedLong(value);
1707   offset+=WriteBlobLong(image,dpx.orientation.y_size);
1708   value=GetImageArtifact(image,"dpx:orientation.filename");
1709   if (value != (const char *) NULL)
1710     (void) strncpy(dpx.orientation.filename,value,
1711       sizeof(dpx.orientation.filename));
1712   offset+=WriteBlob(image,sizeof(dpx.orientation.filename),(unsigned char *)
1713     dpx.orientation.filename);
1714   offset+=WriteBlob(image,sizeof(dpx.orientation.timestamp),(unsigned char *)
1715     dpx.orientation.timestamp);
1716   value=GetImageArtifact(image,"dpx:orientation.device");
1717   if (value != (const char *) NULL)
1718     (void) strncpy(dpx.orientation.device,value,sizeof(dpx.orientation.device));
1719   offset+=WriteBlob(image,sizeof(dpx.orientation.device),(unsigned char *)
1720     dpx.orientation.device);
1721   value=GetImageArtifact(image,"dpx:orientation.serial");
1722   if (value != (const char *) NULL)
1723     (void) strncpy(dpx.orientation.serial,value,sizeof(dpx.orientation.serial));
1724   offset+=WriteBlob(image,sizeof(dpx.orientation.serial),(unsigned char *)
1725     dpx.orientation.serial);
1726   for (i=0; i < 4; i++)
1727     dpx.orientation.border[i]=0;
1728   value=GetImageArtifact(image,"dpx:orientation.border");
1729   if (value != (const char *) NULL)
1730     {
1731       flags=ParseGeometry(value,&geometry_info);
1732       if ((flags & SigmaValue) == 0)
1733         geometry_info.sigma=geometry_info.rho;
1734       dpx.orientation.border[0]=(unsigned short) (geometry_info.rho+0.5);
1735       dpx.orientation.border[1]=(unsigned short) (geometry_info.sigma+0.5);
1736       dpx.orientation.border[2]=(unsigned short) (geometry_info.xi+0.5);
1737       dpx.orientation.border[3]=(unsigned short) (geometry_info.psi+0.5);
1738     }
1739   for (i=0; i < 4; i++)
1740     offset+=WriteBlobShort(image,dpx.orientation.border[i]);
1741   for (i=0; i < 2; i++)
1742     dpx.orientation.aspect_ratio[i]=0U;
1743   value=GetImageArtifact(image,"dpx:orientation.aspect_ratio");
1744   if (value != (const char *) NULL)
1745     {
1746       flags=ParseGeometry(value,&geometry_info);
1747       if ((flags & SigmaValue) == 0)
1748         geometry_info.sigma=geometry_info.rho;
1749       dpx.orientation.aspect_ratio[0]=(unsigned int) (geometry_info.rho+0.5);
1750       dpx.orientation.aspect_ratio[1]=(unsigned int) (geometry_info.sigma+0.5);
1751     }
1752   for (i=0; i < 2; i++)
1753     offset+=WriteBlobLong(image,dpx.orientation.aspect_ratio[i]);
1754   offset+=WriteBlob(image,sizeof(dpx.orientation.reserve),(unsigned char *)
1755     dpx.orientation.reserve);
1756   /*
1757     Write film header.
1758   */
1759   *dpx.film.id='\0';
1760   value=GetImageArtifact(image,"dpx:film.id");
1761   if (value != (const char *) NULL)
1762     (void) strncpy(dpx.film.id,value,sizeof(dpx.film.id));
1763   offset+=WriteBlob(image,sizeof(dpx.film.id),(unsigned char *) dpx.film.id);
1764   *dpx.film.type='\0';
1765   value=GetImageArtifact(image,"dpx:film.type");
1766   if (value != (const char *) NULL)
1767     (void) strncpy(dpx.film.type,value,sizeof(dpx.film.type));
1768   offset+=WriteBlob(image,sizeof(dpx.film.type),(unsigned char *)
1769     dpx.film.type);
1770   *dpx.film.offset='\0';
1771   value=GetImageArtifact(image,"dpx:film.offset");
1772   if (value != (const char *) NULL)
1773     (void) strncpy(dpx.film.offset,value,sizeof(dpx.film.offset));
1774   offset+=WriteBlob(image,sizeof(dpx.film.offset),(unsigned char *)
1775     dpx.film.offset);
1776   *dpx.film.prefix='\0';
1777   value=GetImageArtifact(image,"dpx:film.prefix");
1778   if (value != (const char *) NULL)
1779     (void) strncpy(dpx.film.prefix,value,sizeof(dpx.film.prefix));
1780   offset+=WriteBlob(image,sizeof(dpx.film.prefix),(unsigned char *)
1781     dpx.film.prefix);
1782   *dpx.film.count='\0';
1783   value=GetImageArtifact(image,"dpx:film.count");
1784   if (value != (const char *) NULL)
1785     (void) strncpy(dpx.film.count,value,sizeof(dpx.film.count));
1786   offset+=WriteBlob(image,sizeof(dpx.film.count),(unsigned char *)
1787     dpx.film.count);
1788   *dpx.film.format='\0';
1789   value=GetImageArtifact(image,"dpx:film.format");
1790   if (value != (const char *) NULL)
1791     (void) strncpy(dpx.film.format,value,sizeof(dpx.film.format));
1792   offset+=WriteBlob(image,sizeof(dpx.film.format),(unsigned char *)
1793     dpx.film.format);
1794   dpx.film.frame_position=0U;
1795   value=GetImageArtifact(image,"dpx:film.frame_position");
1796   if (value != (const char *) NULL)
1797     dpx.film.frame_position=(unsigned int) StringToUnsignedLong(value);
1798   offset+=WriteBlobLong(image,dpx.film.frame_position);
1799   dpx.film.sequence_extent=0U;
1800   value=GetImageArtifact(image,"dpx:film.sequence_extent");
1801   if (value != (const char *) NULL)
1802     dpx.film.sequence_extent=(unsigned int) StringToUnsignedLong(value);
1803   offset+=WriteBlobLong(image,dpx.film.sequence_extent);
1804   dpx.film.held_count=0U;
1805   value=GetImageArtifact(image,"dpx:film.held_count");
1806   if (value != (const char *) NULL)
1807     dpx.film.held_count=(unsigned int) StringToUnsignedLong(value);
1808   offset+=WriteBlobLong(image,dpx.film.held_count);
1809   dpx.film.frame_rate=0.0f;
1810   value=GetImageArtifact(image,"dpx:film.frame_rate");
1811   if (value != (const char *) NULL)
1812     dpx.film.frame_rate=StringToDouble(value,(char **) NULL);
1813   offset+=WriteBlobFloat(image,dpx.film.frame_rate);
1814   dpx.film.shutter_angle=0.0f;
1815   value=GetImageArtifact(image,"dpx:film.shutter_angle");
1816   if (value != (const char *) NULL)
1817     dpx.film.shutter_angle=StringToDouble(value,(char **) NULL);
1818   offset+=WriteBlobFloat(image,dpx.film.shutter_angle);
1819   *dpx.film.frame_id='\0';
1820   value=GetImageArtifact(image,"dpx:film.frame_id");
1821   if (value != (const char *) NULL)
1822     (void) strncpy(dpx.film.frame_id,value,sizeof(dpx.film.frame_id));
1823   offset+=WriteBlob(image,sizeof(dpx.film.frame_id),(unsigned char *)
1824     dpx.film.frame_id);
1825   value=GetImageArtifact(image,"dpx:film.slate");
1826   if (value != (const char *) NULL)
1827     (void) strncpy(dpx.film.slate,value,sizeof(dpx.film.slate));
1828   offset+=WriteBlob(image,sizeof(dpx.film.slate),(unsigned char *)
1829     dpx.film.slate);
1830   offset+=WriteBlob(image,sizeof(dpx.film.reserve),(unsigned char *)
1831     dpx.film.reserve);
1832   /*
1833     Write television header.
1834   */
1835   value=GetImageArtifact(image,"dpx:television.time.code");
1836   if (value != (const char *) NULL)
1837     dpx.television.time_code=StringToTimeCode(value);
1838   offset+=WriteBlobLong(image,dpx.television.time_code);
1839   value=GetImageArtifact(image,"dpx:television.user.bits");
1840   if (value != (const char *) NULL)
1841     dpx.television.user_bits=StringToTimeCode(value);
1842   offset+=WriteBlobLong(image,dpx.television.user_bits);
1843   value=GetImageArtifact(image,"dpx:television.interlace");
1844   if (value != (const char *) NULL)
1845     dpx.television.interlace=(unsigned char) StringToLong(value);
1846   offset+=WriteBlobByte(image,dpx.television.interlace);
1847   value=GetImageArtifact(image,"dpx:television.field_number");
1848   if (value != (const char *) NULL)
1849     dpx.television.field_number=(unsigned char) StringToLong(value);
1850   offset+=WriteBlobByte(image,dpx.television.field_number);
1851   dpx.television.video_signal=0;
1852   value=GetImageArtifact(image,"dpx:television.video_signal");
1853   if (value != (const char *) NULL)
1854     dpx.television.video_signal=(unsigned char) StringToLong(value);
1855   offset+=WriteBlobByte(image,dpx.television.video_signal);
1856   dpx.television.padding=0;
1857   value=GetImageArtifact(image,"dpx:television.padding");
1858   if (value != (const char *) NULL)
1859     dpx.television.padding=(unsigned char) StringToLong(value);
1860   offset+=WriteBlobByte(image,dpx.television.padding);
1861   dpx.television.horizontal_sample_rate=0.0f;
1862   value=GetImageArtifact(image,"dpx:television.horizontal_sample_rate");
1863   if (value != (const char *) NULL)
1864     dpx.television.horizontal_sample_rate=StringToDouble(value,(char **) NULL);
1865   offset+=WriteBlobFloat(image,dpx.television.horizontal_sample_rate);
1866   dpx.television.vertical_sample_rate=0.0f;
1867   value=GetImageArtifact(image,"dpx:television.vertical_sample_rate");
1868   if (value != (const char *) NULL)
1869     dpx.television.vertical_sample_rate=StringToDouble(value,(char **) NULL);
1870   offset+=WriteBlobFloat(image,dpx.television.vertical_sample_rate);
1871   dpx.television.frame_rate=0.0f;
1872   value=GetImageArtifact(image,"dpx:television.frame_rate");
1873   if (value != (const char *) NULL)
1874     dpx.television.frame_rate=StringToDouble(value,(char **) NULL);
1875   offset+=WriteBlobFloat(image,dpx.television.frame_rate);
1876   dpx.television.time_offset=0.0f;
1877   value=GetImageArtifact(image,"dpx:television.time_offset");
1878   if (value != (const char *) NULL)
1879     dpx.television.time_offset=StringToDouble(value,(char **) NULL);
1880   offset+=WriteBlobFloat(image,dpx.television.time_offset);
1881   dpx.television.gamma=0.0f;
1882   value=GetImageArtifact(image,"dpx:television.gamma");
1883   if (value != (const char *) NULL)
1884     dpx.television.gamma=StringToDouble(value,(char **) NULL);
1885   offset+=WriteBlobFloat(image,dpx.television.gamma);
1886   dpx.television.black_level=0.0f;
1887   value=GetImageArtifact(image,"dpx:television.black_level");
1888   if (value != (const char *) NULL)
1889     dpx.television.black_level=StringToDouble(value,(char **) NULL);
1890   offset+=WriteBlobFloat(image,dpx.television.black_level);
1891   dpx.television.black_gain=0.0f;
1892   value=GetImageArtifact(image,"dpx:television.black_gain");
1893   if (value != (const char *) NULL)
1894     dpx.television.black_gain=StringToDouble(value,(char **) NULL);
1895   offset+=WriteBlobFloat(image,dpx.television.black_gain);
1896   dpx.television.break_point=0.0f;
1897   value=GetImageArtifact(image,"dpx:television.break_point");
1898   if (value != (const char *) NULL)
1899     dpx.television.break_point=StringToDouble(value,(char **) NULL);
1900   offset+=WriteBlobFloat(image,dpx.television.break_point);
1901   dpx.television.white_level=0.0f;
1902   value=GetImageArtifact(image,"dpx:television.white_level");
1903   if (value != (const char *) NULL)
1904     dpx.television.white_level=StringToDouble(value,(char **) NULL);
1905   offset+=WriteBlobFloat(image,dpx.television.white_level);
1906   dpx.television.integration_times=0.0f;
1907   value=GetImageArtifact(image,"dpx:television.integration_times");
1908   if (value != (const char *) NULL)
1909     dpx.television.integration_times=StringToDouble(value,(char **) NULL);
1910   offset+=WriteBlobFloat(image,dpx.television.integration_times);
1911   offset+=WriteBlob(image,sizeof(dpx.television.reserve),(unsigned char *)
1912     dpx.television.reserve);
1913   /*
1914     Write user header.
1915   */
1916   value=GetImageArtifact(image,"dpx:user.id");
1917   if (value != (const char *) NULL)
1918     (void) strncpy(dpx.user.id,value,sizeof(dpx.user.id));
1919   offset+=WriteBlob(image,sizeof(dpx.user.id),(unsigned char *) dpx.user.id);
1920   if (profile != (StringInfo *) NULL)
1921     offset+=WriteBlob(image,GetStringInfoLength(profile),
1922       GetStringInfoDatum(profile));
1923   while (offset < (MagickOffsetType) dpx.image.image_element[0].data_offset)
1924   {
1925     count=WriteBlobByte(image,0x00);
1926     if (count != 1)
1927       {
1928         ThrowFileException(exception,FileOpenError,"UnableToWriteFile",
1929           image->filename);
1930         break;
1931       }
1932     offset+=count;
1933   }
1934   /*
1935     Convert pixel packets to DPX raster image.
1936   */
1937   quantum_info=AcquireQuantumInfo(image_info,image);
1938   SetQuantumQuantum(quantum_info,32);
1939   SetQuantumPack(quantum_info,dpx.image.image_element[0].packing == 0 ?
1940     MagickTrue : MagickFalse);
1941   quantum_type=RGBQuantum;
1942   if (image->alpha_trait == BlendPixelTrait)
1943     quantum_type=RGBAQuantum;
1944   if (image->colorspace == YCbCrColorspace)
1945     {
1946       quantum_type=CbYCrQuantum;
1947       if (image->alpha_trait == BlendPixelTrait)
1948         quantum_type=CbYCrAQuantum;
1949       if ((horizontal_factor == 2) || (vertical_factor == 2))
1950         quantum_type=CbYCrYQuantum;
1951     }
1952   extent=GetBytesPerRow(image->columns,image->alpha_trait == BlendPixelTrait ?
1953     4UL : 3UL,image->depth,MagickTrue);
1954   if ((image_info->type != TrueColorType) &&
1955       (image->alpha_trait != BlendPixelTrait) &&
1956       (IsImageGray(image,exception) != MagickFalse))
1957     {
1958       quantum_type=GrayQuantum;
1959       extent=GetBytesPerRow(image->columns,1UL,image->depth,MagickTrue);
1960     }
1961   pixels=GetQuantumPixels(quantum_info);
1962   for (y=0; y < (ssize_t) image->rows; y++)
1963   {
1964     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1965     if (p == (const Quantum *) NULL)
1966       break;
1967     (void) ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1968       quantum_type,pixels,exception);
1969     count=WriteBlob(image,extent,pixels);
1970     if (count != (ssize_t) extent)
1971       break;
1972     status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1973       image->rows);
1974     if (status == MagickFalse)
1975       break;
1976   }
1977   quantum_info=DestroyQuantumInfo(quantum_info);
1978   (void) CloseBlob(image);
1979   return(status);
1980 }