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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                        M   M  PPPP   EEEEE   GGGG                           %
   7 %                        MM MM  P   P  E      G                               %
   8 %                        M M M  PPPP   EEE    G  GG                           %
   9 %                        M   M  P      E      G   G                           %
  10 %                        M   M  P      EEEEE   GGGG                           %
  11 %                                                                             %
  12 %                                                                             %
  13 %                       Read/Write MPEG Image Format                          %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                   Cristy                                    %
  17 %                                 July 1999                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2018 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 %    https://www.imagemagick.org/script/license.php                           %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 /*
  39   Include declarations.
  40 */
  41 #include "MagickCore/studio.h"
  42 #include "MagickCore/blob.h"
  43 #include "MagickCore/blob-private.h"
  44 #include "MagickCore/constitute.h"
  45 #include "MagickCore/delegate.h"
  46 #include "MagickCore/exception.h"
  47 #include "MagickCore/exception-private.h"
  48 #include "MagickCore/geometry.h"
  49 #include "MagickCore/image.h"
  50 #include "MagickCore/image-private.h"
  51 #include "MagickCore/layer.h"
  52 #include "MagickCore/list.h"
  53 #include "MagickCore/log.h"
  54 #include "MagickCore/magick.h"
  55 #include "MagickCore/memory_.h"
  56 #include "MagickCore/resource_.h"
  57 #include "MagickCore/quantum-private.h"
  58 #include "MagickCore/static.h"
  59 #include "MagickCore/string_.h"
  60 #include "MagickCore/module.h"
  61 #include "MagickCore/transform.h"
  62 #include "MagickCore/utility.h"
  63 #include "MagickCore/utility-private.h"
  64 \f
  65 /*
  66   Forward declarations.
  67 */
  68 static MagickBooleanType
  69   WriteMPEGImage(const ImageInfo *,Image *,ExceptionInfo *);
  70 \f
  71 /*
  72 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  73 %                                                                             %
  74 %                                                                             %
  75 %                                                                             %
  76 %   I s A V I                                                                 %
  77 %                                                                             %
  78 %                                                                             %
  79 %                                                                             %
  80 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  81 %
  82 %  IsAVI() returns MagickTrue if the image format type, identified by the
  83 %  magick string, is Audio/Video Interleaved file format.
  84 %
  85 %  The format of the IsAVI method is:
  86 %
  87 %      size_t IsAVI(const unsigned char *magick,const size_t length)
  88 %
  89 %  A description of each parameter follows:
  90 %
  91 %    o magick: compare image format pattern against these bytes.
  92 %
  93 %    o length: Specifies the length of the magick string.
  94 %
  95 */
  96 static MagickBooleanType IsAVI(const unsigned char *magick,const size_t length)
  97 {
  98   if (length < 4)
  99     return(MagickFalse);
 100   if (memcmp(magick,"RIFF",4) == 0)
 101     return(MagickTrue);
 102   return(MagickFalse);
 103 }
 104 \f
 105 /*
 106 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 107 %                                                                             %
 108 %                                                                             %
 109 %                                                                             %
 110 %   I s M P E G                                                               %
 111 %                                                                             %
 112 %                                                                             %
 113 %                                                                             %
 114 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 115 %
 116 %  IsMPEG() returns MagickTrue if the image format type, identified by the
 117 %  magick string, is MPEG.
 118 %
 119 %  The format of the IsMPEG method is:
 120 %
 121 %      MagickBooleanType IsMPEG(const unsigned char *magick,const size_t length)
 122 %
 123 %  A description of each parameter follows:
 124 %
 125 %    o magick: compare image format pattern against these bytes.
 126 %
 127 %    o length: Specifies the length of the magick string.
 128 %
 129 */
 130 static MagickBooleanType IsMPEG(const unsigned char *magick,const size_t length)
 131 {
 132   if (length < 4)
 133     return(MagickFalse);
 134   if (memcmp(magick,"\000\000\001\263",4) == 0)
 135     return(MagickTrue);
 136   return(MagickFalse);
 137 }
 138 \f
 139 /*
 140 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 141 %                                                                             %
 142 %                                                                             %
 143 %                                                                             %
 144 %   R e a d M P E G I m a g e                                                 %
 145 %                                                                             %
 146 %                                                                             %
 147 %                                                                             %
 148 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 149 %
 150 %  ReadMPEGImage() reads an binary file in the MPEG video stream format
 151 %  and returns it.  It allocates the memory necessary for the new Image
 152 %  structure and returns a pointer to the new image.
 153 %
 154 %  The format of the ReadMPEGImage method is:
 155 %
 156 %      Image *ReadMPEGImage(const ImageInfo *image_info,
 157 %        ExceptionInfo *exception)
 158 %
 159 %  A description of each parameter follows:
 160 %
 161 %    o image_info: the image info.
 162 %
 163 %    o exception: return any errors or warnings in this structure.
 164 %
 165 */
 166 static Image *ReadMPEGImage(const ImageInfo *image_info,
 167   ExceptionInfo *exception)
 168 {
 169 #define ReadMPEGIntermediateFormat "pam"
 170
 171   Image
 172     *image,
 173     *images,
 174     *next;
 175
 176   ImageInfo
 177     *read_info;
 178
 179   MagickBooleanType
 180     status;
 181
 182   /*
 183     Open image file.
 184   */
 185   assert(image_info != (const ImageInfo *) NULL);
 186   assert(image_info->signature == MagickCoreSignature);
 187   if (image_info->debug != MagickFalse)
 188     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 189       image_info->filename);
 190   assert(exception != (ExceptionInfo *) NULL);
 191   assert(exception->signature == MagickCoreSignature);
 192   image=AcquireImage(image_info,exception);
 193   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 194   if (status == MagickFalse)
 195     {
 196       image=DestroyImageList(image);
 197       return((Image *) NULL);
 198     }
 199   (void) CloseBlob(image);
 200   (void) DestroyImageList(image);
 201   /*
 202     Convert MPEG to PAM with delegate.
 203   */
 204   read_info=CloneImageInfo(image_info);
 205   image=AcquireImage(image_info,exception);
 206   (void) InvokeDelegate(read_info,image,"mpeg:decode",(char *) NULL,exception);
 207   (void) FormatLocaleString(read_info->filename,MagickPathExtent,"%s.%s",
 208     read_info->unique,ReadMPEGIntermediateFormat);
 209   images=ReadImage(read_info,exception);
 210   if (images != (Image *) NULL)
 211     for (next=images; next != (Image *) NULL; next=next->next)
 212     {
 213       (void) CopyMagickString(next->filename,image->filename,MagickPathExtent);
 214       (void) CopyMagickString(next->magick,image->magick,MagickPathExtent);
 215     }
 216   (void) RelinquishUniqueFileResource(read_info->filename);
 217   read_info=DestroyImageInfo(read_info);
 218   image=DestroyImage(image);
 219   return(images);
 220 }
 221 \f
 222 /*
 223 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 224 %                                                                             %
 225 %                                                                             %
 226 %                                                                             %
 227 %   R e g i s t e r M P E G I m a g e                                         %
 228 %                                                                             %
 229 %                                                                             %
 230 %                                                                             %
 231 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 232 %
 233 %  RegisterMPEGImage() adds attributes for the MPEG image format to
 234 %  the list of supported formats.  The attributes include the image format
 235 %  tag, a method to read and/or write the format, whether the format
 236 %  supports the saving of more than one frame to the same file or blob,
 237 %  whether the format supports native in-memory I/O, and a brief
 238 %  description of the format.
 239 %
 240 %  The format of the RegisterMPEGImage method is:
 241 %
 242 %      size_t RegisterMPEGImage(void)
 243 %
 244 */
 245 ModuleExport size_t RegisterMPEGImage(void)
 246 {
 247   MagickInfo
 248     *entry;
 249
 250   entry=AcquireMagickInfo("MPEG","3GP","Media Container");
 251   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 252   entry->flags^=CoderBlobSupportFlag;
 253   entry->flags|=CoderSeekableStreamFlag;
 254   (void) RegisterMagickInfo(entry);
 255   entry=AcquireMagickInfo("MPEG","3G2","Media Container");
 256   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 257   entry->flags^=CoderBlobSupportFlag;
 258   entry->flags|=CoderSeekableStreamFlag;
 259   (void) RegisterMagickInfo(entry);
 260   entry=AcquireMagickInfo("MPEG","AVI","Microsoft Audio/Visual Interleaved");
 261   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 262   entry->magick=(IsImageFormatHandler *) IsAVI;
 263   entry->flags^=CoderBlobSupportFlag;
 264   (void) RegisterMagickInfo(entry);
 265   entry=AcquireMagickInfo("MPEG","MKV","Multimedia Container");
 266   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 267   entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
 268   entry->magick=(IsImageFormatHandler *) IsMPEG;
 269   entry->flags^=CoderBlobSupportFlag;
 270   (void) RegisterMagickInfo(entry);
 271   entry=AcquireMagickInfo("MPEG","MOV","MPEG Video Stream");
 272   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 273   entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
 274   entry->magick=(IsImageFormatHandler *) IsMPEG;
 275   entry->flags^=CoderBlobSupportFlag;
 276   (void) RegisterMagickInfo(entry);
 277   entry=AcquireMagickInfo("MPEG","MPEG","MPEG Video Stream");
 278   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 279   entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
 280   entry->magick=(IsImageFormatHandler *) IsMPEG;
 281   entry->flags^=CoderBlobSupportFlag;
 282   (void) RegisterMagickInfo(entry);
 283   entry=AcquireMagickInfo("MPEG","MPG","MPEG Video Stream");
 284   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 285   entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
 286   entry->magick=(IsImageFormatHandler *) IsMPEG;
 287   entry->flags^=CoderBlobSupportFlag;
 288   (void) RegisterMagickInfo(entry);
 289   entry=AcquireMagickInfo("MPEG","MP4","MPEG-4 Video Stream");
 290   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 291   entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
 292   entry->magick=(IsImageFormatHandler *) IsMPEG;
 293   entry->flags^=CoderBlobSupportFlag;
 294   (void) RegisterMagickInfo(entry);
 295   entry=AcquireMagickInfo("MPEG","M2V","MPEG Video Stream");
 296   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 297   entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
 298   entry->magick=(IsImageFormatHandler *) IsMPEG;
 299   entry->flags^=CoderBlobSupportFlag;
 300   (void) RegisterMagickInfo(entry);
 301   entry=AcquireMagickInfo("MPEG","M4V","Raw MPEG-4 Video");
 302   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 303   entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
 304   entry->magick=(IsImageFormatHandler *) IsMPEG;
 305   entry->flags^=CoderBlobSupportFlag;
 306   (void) RegisterMagickInfo(entry);
 307   entry=AcquireMagickInfo("MPEG","WMV","Windows Media Video");
 308   entry->decoder=(DecodeImageHandler *) ReadMPEGImage;
 309   entry->encoder=(EncodeImageHandler *) WriteMPEGImage;
 310   entry->magick=(IsImageFormatHandler *) IsMPEG;
 311   entry->flags^=CoderBlobSupportFlag;
 312   (void) RegisterMagickInfo(entry);
 313   return(MagickImageCoderSignature);
 314 }
 315 \f
 316 /*
 317 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 318 %                                                                             %
 319 %                                                                             %
 320 %                                                                             %
 321 %   U n r e g i s t e r M P E G I m a g e                                     %
 322 %                                                                             %
 323 %                                                                             %
 324 %                                                                             %
 325 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 326 %
 327 %  UnregisterMPEGImage() removes format registrations made by the
 328 %  BIM module from the list of supported formats.
 329 %
 330 %  The format of the UnregisterBIMImage method is:
 331 %
 332 %      UnregisterMPEGImage(void)
 333 %
 334 */
 335 ModuleExport void UnregisterMPEGImage(void)
 336 {
 337   (void) UnregisterMagickInfo("WMV");
 338   (void) UnregisterMagickInfo("MOV");
 339   (void) UnregisterMagickInfo("M4V");
 340   (void) UnregisterMagickInfo("M2V");
 341   (void) UnregisterMagickInfo("MP4");
 342   (void) UnregisterMagickInfo("MPG");
 343   (void) UnregisterMagickInfo("MPEG");
 344   (void) UnregisterMagickInfo("MKV");
 345   (void) UnregisterMagickInfo("AVI");
 346   (void) UnregisterMagickInfo("3G2");
 347   (void) UnregisterMagickInfo("3GP");
 348 }
 349 \f
 350 /*
 351 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 352 %                                                                             %
 353 %                                                                             %
 354 %                                                                             %
 355 %   W r i t e M P E G I m a g e                                               %
 356 %                                                                             %
 357 %                                                                             %
 358 %                                                                             %
 359 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 360 %
 361 %  WriteMPEGImage() writes an image to a file in MPEG video stream format.
 362 %  Lawrence Livermore National Laboratory (LLNL) contributed code to adjust
 363 %  the MPEG parameters to correspond to the compression quality setting.
 364 %
 365 %  The format of the WriteMPEGImage method is:
 366 %
 367 %      MagickBooleanType WriteMPEGImage(const ImageInfo *image_info,
 368 %        Image *image,ExceptionInfo *exception)
 369 %
 370 %  A description of each parameter follows.
 371 %
 372 %    o image_info: the image info.
 373 %
 374 %    o image:  The image.
 375 %
 376 %    o exception: return any errors or warnings in this structure.
 377 %
 378 */
 379 static MagickBooleanType CopyDelegateFile(const char *source,
 380   const char *destination)
 381 {
 382   int
 383     destination_file,
 384     source_file;
 385
 386   MagickBooleanType
 387     status;
 388
 389   register size_t
 390     i;
 391
 392   size_t
 393     length,
 394     quantum;
 395
 396   ssize_t
 397     count;
 398
 399   struct stat
 400     attributes;
 401
 402   unsigned char
 403     *buffer;
 404
 405   /*
 406     Return if destination file already exists and is not empty.
 407   */
 408   assert(source != (const char *) NULL);
 409   assert(destination != (char *) NULL);
 410   status=GetPathAttributes(destination,&attributes);
 411   if ((status != MagickFalse) && (attributes.st_size > 0))
 412     return(MagickTrue);
 413   /*
 414     Copy source file to destination.
 415   */
 416   destination_file=open_utf8(destination,O_WRONLY | O_BINARY | O_CREAT,S_MODE);
 417   if (destination_file == -1)
 418     return(MagickFalse);
 419   source_file=open_utf8(source,O_RDONLY | O_BINARY,0);
 420   if (source_file == -1)
 421     {
 422       (void) close(destination_file);
 423       return(MagickFalse);
 424     }
 425   quantum=(size_t) MagickMaxBufferExtent;
 426   if ((fstat(source_file,&attributes) == 0) && (attributes.st_size > 0))
 427     quantum=(size_t) MagickMin((double) attributes.st_size,
 428       MagickMaxBufferExtent);
 429   buffer=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*buffer));
 430   if (buffer == (unsigned char *) NULL)
 431     {
 432       (void) close(source_file);
 433       (void) close(destination_file);
 434       return(MagickFalse);
 435     }
 436   length=0;
 437   for (i=0; ; i+=count)
 438   {
 439     count=(ssize_t) read(source_file,buffer,quantum);
 440     if (count <= 0)
 441       break;
 442     length=(size_t) count;
 443     count=(ssize_t) write(destination_file,buffer,length);
 444     if ((size_t) count != length)
 445       break;
 446   }
 447   (void) close(destination_file);
 448   (void) close(source_file);
 449   buffer=(unsigned char *) RelinquishMagickMemory(buffer);
 450   return(i != 0 ? MagickTrue : MagickFalse);
 451 }
 452
 453 static MagickBooleanType WriteMPEGImage(const ImageInfo *image_info,
 454   Image *image,ExceptionInfo *exception)
 455 {
 456 #define WriteMPEGIntermediateFormat "jpg"
 457
 458   char
 459     basename[MagickPathExtent],
 460     filename[MagickPathExtent];
 461
 462   double
 463     delay;
 464
 465   Image
 466     *coalesce_image;
 467
 468   ImageInfo
 469     *write_info;
 470
 471   int
 472     file;
 473
 474   MagickBooleanType
 475     status;
 476
 477   register Image
 478     *p;
 479
 480   register ssize_t
 481     i;
 482
 483   size_t
 484     count,
 485     length,
 486     scene;
 487
 488   unsigned char
 489     *blob;
 490
 491   /*
 492     Open output image file.
 493   */
 494   assert(image_info != (const ImageInfo *) NULL);
 495   assert(image_info->signature == MagickCoreSignature);
 496   assert(image != (Image *) NULL);
 497   assert(image->signature == MagickCoreSignature);
 498   if (image->debug != MagickFalse)
 499     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 500   assert(exception != (ExceptionInfo *) NULL);
 501   assert(exception->signature == MagickCoreSignature);
 502   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
 503   if (status == MagickFalse)
 504     return(status);
 505   (void) CloseBlob(image);
 506   /*
 507     Write intermediate files.
 508   */
 509   coalesce_image=CoalesceImages(image,exception);
 510   if (coalesce_image == (Image *) NULL)
 511     return(MagickFalse);
 512   file=AcquireUniqueFileResource(basename);
 513   if (file != -1)
 514     file=close(file)-1;
 515   (void) FormatLocaleString(coalesce_image->filename,MagickPathExtent,"%s",
 516     basename);
 517   count=0;
 518   write_info=CloneImageInfo(image_info);
 519   *write_info->magick='\0';
 520   for (p=coalesce_image; p != (Image *) NULL; p=GetNextImageInList(p))
 521   {
 522     char
 523       previous_image[MagickPathExtent];
 524
 525     blob=(unsigned char *) NULL;
 526     length=0;
 527     scene=p->scene;
 528     delay=100.0*p->delay/MagickMax(1.0*p->ticks_per_second,1.0);
 529     for (i=0; i < (ssize_t) MagickMax((1.0*delay+1.0)/3.0,1.0); i++)
 530     {
 531       p->scene=count;
 532       count++;
 533       status=MagickFalse;
 534       switch (i)
 535       {
 536         case 0:
 537         {
 538           Image
 539             *frame;
 540
 541           (void) FormatLocaleString(p->filename,MagickPathExtent,"%s%.20g.%s",
 542             basename,(double) p->scene,WriteMPEGIntermediateFormat);
 543           (void) FormatLocaleString(filename,MagickPathExtent,"%s%.20g.%s",
 544             basename,(double) p->scene,WriteMPEGIntermediateFormat);
 545           (void) FormatLocaleString(previous_image,MagickPathExtent,
 546             "%s%.20g.%s",basename,(double) p->scene,
 547             WriteMPEGIntermediateFormat);
 548           frame=CloneImage(p,0,0,MagickTrue,exception);
 549           if (frame == (Image *) NULL)
 550             break;
 551           status=WriteImage(write_info,frame,exception);
 552           frame=DestroyImage(frame);
 553           break;
 554         }
 555         case 1:
 556         {
 557           blob=(unsigned char *) FileToBlob(previous_image,~0UL,&length,
 558             exception);
 559         }
 560         default:
 561         {
 562           (void) FormatLocaleString(filename,MagickPathExtent,"%s%.20g.%s",
 563             basename,(double) p->scene,WriteMPEGIntermediateFormat);
 564           if (length > 0)
 565             status=BlobToFile(filename,blob,length,exception);
 566           break;
 567         }
 568       }
 569       if (image->debug != MagickFalse)
 570         {
 571           if (status != MagickFalse)
 572             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 573               "%.20g. Wrote %s file for scene %.20g:",(double) i,
 574               WriteMPEGIntermediateFormat,(double) p->scene);
 575           else
 576             (void) LogMagickEvent(CoderEvent,GetMagickModule(),
 577               "%.20g. Failed to write %s file for scene %.20g:",(double) i,
 578               WriteMPEGIntermediateFormat,(double) p->scene);
 579           (void) LogMagickEvent(CoderEvent,GetMagickModule(),"%s",filename);
 580         }
 581     }
 582     p->scene=scene;
 583     if (blob != (unsigned char *) NULL)
 584       blob=(unsigned char *) RelinquishMagickMemory(blob);
 585     if (status == MagickFalse)
 586       break;
 587   }
 588   /*
 589     Convert JPEG to MPEG.
 590   */
 591   (void) CopyMagickString(coalesce_image->magick_filename,basename,
 592     MagickPathExtent);
 593   (void) CopyMagickString(coalesce_image->filename,basename,MagickPathExtent);
 594   GetPathComponent(image_info->filename,ExtensionPath,coalesce_image->magick);
 595   if (*coalesce_image->magick == '\0')
 596     (void) CopyMagickString(coalesce_image->magick,image->magick,
 597       MagickPathExtent);
 598   status=InvokeDelegate(write_info,coalesce_image,(char *) NULL,"mpeg:encode",
 599     exception);
 600   (void) FormatLocaleString(write_info->filename,MagickPathExtent,"%s.%s",
 601     write_info->unique,coalesce_image->magick);
 602   status=CopyDelegateFile(write_info->filename,image->filename);
 603   (void) RelinquishUniqueFileResource(write_info->filename);
 604   write_info=DestroyImageInfo(write_info);
 605   /*
 606     Relinquish resources.
 607   */
 608   count=0;
 609   for (p=coalesce_image; p != (Image *) NULL; p=GetNextImageInList(p))
 610   {
 611     delay=100.0*p->delay/MagickMax(1.0*p->ticks_per_second,1.0);
 612     for (i=0; i < (ssize_t) MagickMax((1.0*delay+1.0)/3.0,1.0); i++)
 613     {
 614       (void) FormatLocaleString(p->filename,MagickPathExtent,"%s%.20g.%s",
 615         basename,(double) count++,WriteMPEGIntermediateFormat);
 616       (void) RelinquishUniqueFileResource(p->filename);
 617     }
 618     (void) CopyMagickString(p->filename,image_info->filename,MagickPathExtent);
 619   }
 620   (void) RelinquishUniqueFileResource(basename);
 621   coalesce_image=DestroyImageList(coalesce_image);
 622   if (image->debug != MagickFalse)
 623     (void) LogMagickEvent(CoderEvent,GetMagickModule(),"exit");
 624   return(status);
 625 }