granicus.if.org Git - imagemagick/blob - magick/list.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                         L      IIIII  SSSSS  TTTTT                          %
   7 %                         L        I    SS       T                            %
   8 %                         L        I     SSS     T                            %
   9 %                         L        I       SS    T                            %
  10 %                         LLLLL  IIIII  SSSSS    T                            %
  11 %                                                                             %
  12 %                                                                             %
  13 %                        MagickCore Image List Methods                        %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                               December 2002                                 %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 %
  38 */
  39 \f
  40 /*
  41   Include declarations.
  42 */
  43 #include "magick/studio.h"
  44 #include "magick/blob.h"
  45 #include "magick/blob-private.h"
  46 #include "magick/exception.h"
  47 #include "magick/exception-private.h"
  48 #include "magick/list.h"
  49 #include "magick/memory_.h"
  50 #include "magick/string_.h"
  51 \f
  52 /*
  53 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  54 %                                                                             %
  55 %                                                                             %
  56 %                                                                             %
  57 %   A p p e n d I m a g e T o L i s t                                         %
  58 %                                                                             %
  59 %                                                                             %
  60 %                                                                             %
  61 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  62 %
  63 %  AppendImageToList() appends the second image list to the end of the first
  64 %  list.  The given image list pointer is left unchanged, unless it was empty.
  65 %
  66 %  The format of the AppendImageToList method is:
  67 %
  68 %      AppendImageToList(Image *images,const Image *image)
  69 %
  70 %  A description of each parameter follows:
  71 %
  72 %    o images: the image list to be appended to.
  73 %
  74 %    o image: the appended image or image list.
  75 %
  76 */
  77 MagickExport void AppendImageToList(Image **images,const Image *image)
  78 {
  79   register Image
  80     *p,
  81     *q;
  82
  83   assert(images != (Image **) NULL);
  84   if (image == (Image *) NULL)
  85     return;
  86   assert(image->signature == MagickSignature);
  87   if (image->debug != MagickFalse)
  88     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
  89   if ((*images) == (Image *) NULL)
  90     {
  91       *images=(Image *) image;
  92       return;
  93     }
  94   assert((*images)->signature == MagickSignature);
  95   p=GetLastImageInList(*images);
  96   q=GetFirstImageInList(image);
  97   p->next=q;
  98   q->previous=p;
  99 }
 100 \f
 101 /*
 102 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 103 %                                                                             %
 104 %                                                                             %
 105 %                                                                             %
 106 %   C l o n e I m a g e L i s t                                               %
 107 %                                                                             %
 108 %                                                                             %
 109 %                                                                             %
 110 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 111 %
 112 %  CloneImageList() returns a duplicate of the image list.
 113 %
 114 %  The format of the CloneImageList method is:
 115 %
 116 %      Image *CloneImageList(const Image *images,ExceptionInfo *exception)
 117 %
 118 %  A description of each parameter follows:
 119 %
 120 %    o images: the image list.
 121 %
 122 %    o exception: return any errors or warnings in this structure.
 123 %
 124 */
 125 MagickExport Image *CloneImageList(const Image *images,ExceptionInfo *exception)
 126 {
 127   Image
 128     *clone,
 129     *image;
 130
 131   register Image
 132     *p;
 133
 134   if (images == (Image *) NULL)
 135     return((Image *) NULL);
 136   assert(images->signature == MagickSignature);
 137   while (images->previous != (Image *) NULL)
 138     images=images->previous;
 139   image=(Image *) NULL;
 140   for (p=(Image *) NULL; images != (Image *) NULL; images=images->next)
 141   {
 142     clone=CloneImage(images,0,0,MagickTrue,exception);
 143     if (clone == (Image *) NULL)
 144       {
 145         if (image != (Image *) NULL)
 146           image=DestroyImageList(image);
 147         return((Image *) NULL);
 148       }
 149     if (image == (Image *) NULL)
 150       {
 151         image=clone;
 152         p=image;
 153         continue;
 154       }
 155     p->next=clone;
 156     clone->previous=p;
 157     p=p->next;
 158   }
 159   return(image);
 160 }
 161 \f
 162 /*
 163 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 164 %                                                                             %
 165 %                                                                             %
 166 %                                                                             %
 167 %   C l o n e I m a g e s                                                     %
 168 %                                                                             %
 169 %                                                                             %
 170 %                                                                             %
 171 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 172 %
 173 %  CloneImages() clones one or more images from an image sequence, using a
 174 %  comma separated list of image numbers or ranges.
 175 %
 176 %  The numbers start at 0 for the first image in the list, while negative
 177 %  numbers refer to images starting counting from the end of the range. Images
 178 %  may be refered to multiple times to clone them multiple times. Images
 179 %  refered beyond the available number of images in list are ignored.
 180 %
 181 %  Images referenced may be reversed, and results in a clone of those images
 182 %  also being made with a reversed order.
 183 %
 184 %  The format of the CloneImages method is:
 185 %
 186 %      Image *CloneImages(const Image *images,const char *scenes,
 187 %        ExceptionInfo *exception)
 188 %
 189 %  A description of each parameter follows:
 190 %
 191 %    o images: the image sequence.
 192 %
 193 %    o scenes: This character string specifies which scenes to clone
 194 %      (e.g. 1,3-5,7-3,2).
 195 %
 196 %    o exception: return any errors or warnings in this structure.
 197 %
 198 */
 199 MagickExport Image *CloneImages(const Image *images,const char *scenes,
 200   ExceptionInfo *exception)
 201 {
 202   char
 203     *p;
 204
 205   const Image
 206     *next;
 207
 208   Image
 209     *clone_images,
 210     *image;
 211
 212   long
 213     first,
 214     last,
 215     step;
 216
 217   register ssize_t
 218     i;
 219
 220   size_t
 221     length;
 222
 223   assert(images != (const Image *) NULL);
 224   assert(images->signature == MagickSignature);
 225   assert(scenes != (char *) NULL);
 226   if (images->debug != MagickFalse)
 227     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 228   assert(exception != (ExceptionInfo *) NULL);
 229   assert(exception->signature == MagickSignature);
 230   clone_images=NewImageList();
 231   images=GetFirstImageInList(images);
 232   length=GetImageListLength(images);
 233   for (p=(char *) scenes; *p != '\0';)
 234   {
 235     while ((isspace((int) ((unsigned char) *p)) != 0) || (*p == ','))
 236       p++;
 237     first=strtol(p,&p,10);
 238     if (first < 0)
 239       first+=(long) length;
 240     last=first;
 241     while (isspace((int) ((unsigned char) *p)) != 0)
 242       p++;
 243     if (*p == '-')
 244       {
 245         last=strtol(p+1,&p,10);
 246         if (last < 0)
 247           last+=(long) length;
 248       }
 249     for (step=first > last ? -1 : 1; first != (last+step); first+=step)
 250     {
 251       i=0;
 252       for (next=images; next != (Image *) NULL; next=GetNextImageInList(next))
 253       {
 254         if (i == (ssize_t) first)
 255           {
 256             image=CloneImage(next,0,0,MagickTrue,exception);
 257             if (image == (Image *) NULL)
 258               break;
 259             AppendImageToList(&clone_images,image);
 260           }
 261         i++;
 262       }
 263     }
 264   }
 265   return(GetFirstImageInList(clone_images));
 266 }
 267 \f
 268 /*
 269 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 270 %                                                                             %
 271 %                                                                             %
 272 %                                                                             %
 273 %   D e l e t e I m a g e F r o m L i s t                                     %
 274 %                                                                             %
 275 %                                                                             %
 276 %                                                                             %
 277 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 278 %
 279 %  DeleteImageFromList() deletes an image from the list. List pointer
 280 %  is moved to the next image, if one is present. See RemoveImageFromList().
 281 %
 282 %  The format of the DeleteImageFromList method is:
 283 %
 284 %      DeleteImageFromList(Image **images)
 285 %
 286 %  A description of each parameter follows:
 287 %
 288 %    o images: the image list.
 289 %
 290 */
 291 MagickExport void DeleteImageFromList(Image **images)
 292 {
 293   Image
 294     *image;
 295
 296   image=RemoveImageFromList(images);
 297   if (image != (Image *) NULL)
 298     (void) DestroyImage(image);
 299 }
 300 \f
 301 /*
 302 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 303 %                                                                             %
 304 %                                                                             %
 305 %                                                                             %
 306 %   D e l e t e I m a g e s                                                   %
 307 %                                                                             %
 308 %                                                                             %
 309 %                                                                             %
 310 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 311 %
 312 %  DeleteImages() deletes one or more images from an image sequence, using a
 313 %  comma separated list of image numbers or ranges.
 314 %
 315 %  The numbers start at 0 for the first image, while negative numbers refer to
 316 %  images starting counting from the end of the range. Images may be refered to
 317 %  multiple times without problems. Image refered beyond the available number
 318 %  of images in list are ignored.
 319 %
 320 %  If the referenced images are in the reverse order, that range will be
 321 %  completely ignored, unlike CloneImages().
 322 %
 323 %  The format of the DeleteImages method is:
 324 %
 325 %      DeleteImages(Image **images,const char *scenes,ExceptionInfo *exception)
 326 %
 327 %  A description of each parameter follows:
 328 %
 329 %    o images: the image sequence.
 330 %
 331 %    o scenes: This character string specifies which scenes to delete
 332 %      (e.g. 1,3-5,-2-6,2).
 333 %
 334 %    o exception: return any errors or warnings in this structure.
 335 %
 336 */
 337 MagickExport void DeleteImages(Image **images,const char *scenes,
 338   ExceptionInfo *exception)
 339 {
 340   char
 341     *p;
 342
 343   Image
 344     *image;
 345
 346   long
 347     first,
 348     last;
 349
 350   MagickBooleanType
 351     *delete_list;
 352
 353   register ssize_t
 354     i;
 355
 356   size_t
 357     length;
 358
 359   assert(images != (Image **) NULL);
 360   assert((*images)->signature == MagickSignature);
 361   assert(scenes != (char *) NULL);
 362   if ((*images)->debug != MagickFalse)
 363     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 364       (*images)->filename);
 365   assert(exception != (ExceptionInfo *) NULL);
 366   assert(exception->signature == MagickSignature);
 367   *images=GetFirstImageInList(*images);
 368   length=GetImageListLength(*images);
 369   delete_list=(MagickBooleanType *) AcquireQuantumMemory(length,
 370     sizeof(*delete_list));
 371   if (delete_list == (MagickBooleanType *) NULL)
 372     {
 373       (void) ThrowMagickException(exception,GetMagickModule(),
 374         ResourceLimitError,"MemoryAllocationFailed","`%s'",(*images)->filename);
 375       return;
 376     }
 377   image=(*images);
 378   for (i=0; i < (ssize_t) length; i++)
 379     delete_list[i]=MagickFalse;
 380   /*
 381     Note which images will be deleted, avoid duplicate deleted
 382   */
 383   for (p=(char *) scenes; *p != '\0';)
 384   {
 385     while ((isspace((int) *p) != 0) || (*p == ','))
 386       p++;
 387     first=strtol(p,&p,10);
 388     if (first < 0)
 389       first+=(long) length;
 390     last=first;
 391     while (isspace((int) ((unsigned char) *p)) != 0)
 392       p++;
 393     if (*p == '-')
 394       {
 395         last=strtol(p+1,&p,10);
 396         if (last < 0)
 397           last+=(long) length;
 398       }
 399     if (first > last)
 400       continue;
 401     for (i=(ssize_t) first; i <= (ssize_t) last; i++)
 402       if ((i >= 0) && (i < (ssize_t) length))
 403         delete_list[i]=MagickTrue;
 404   }
 405   /*
 406     Delete images marked for deletion, once only
 407   */
 408   image=(*images);
 409   for (i=0; i < (ssize_t) length; i++)
 410   {
 411     *images=image;
 412     image=GetNextImageInList(image);
 413     if (delete_list[i] != MagickFalse)
 414       DeleteImageFromList(images);
 415
 416   }
 417   (void) RelinquishMagickMemory(delete_list);
 418   *images=GetFirstImageInList(*images);
 419 }
 420 \f
 421 /*
 422 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 423 %                                                                             %
 424 %                                                                             %
 425 %                                                                             %
 426 %   D e s t r o y I m a g e L i s t                                           %
 427 %                                                                             %
 428 %                                                                             %
 429 %                                                                             %
 430 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 431 %
 432 %  DestroyImageList() destroys an image list.
 433 %
 434 %  The format of the DestroyImageList method is:
 435 %
 436 %      Image *DestroyImageList(Image *image)
 437 %
 438 %  A description of each parameter follows:
 439 %
 440 %    o image: the image sequence.
 441 %
 442 */
 443 MagickExport Image *DestroyImageList(Image *images)
 444 {
 445   if (images == (Image *) NULL)
 446     return((Image *) NULL);
 447   assert(images->signature == MagickSignature);
 448   if (images->debug != MagickFalse)
 449     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 450   while (images != (Image *) NULL)
 451     DeleteImageFromList(&images);
 452   return((Image *) NULL);
 453 }
 454 \f
 455 /*
 456 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 457 %                                                                             %
 458 %                                                                             %
 459 %                                                                             %
 460 %   D u p l i c a t e I m a g e s                                             %
 461 %                                                                             %
 462 %                                                                             %
 463 %                                                                             %
 464 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 465 %
 466 %  DuplicateImages() duplicates one or more images from an image sequence,
 467 %  using a count and a comma separated list of image numbers or ranges.
 468 %
 469 %  The numbers start at 0 for the first image, while negative numbers refer to
 470 %  images starting counting from the end of the range. Images may be refered to
 471 %  multiple times without problems. Image refered beyond the available number
 472 %  of images in list are ignored.
 473 %
 474 %  The format of the DuplicateImages method is:
 475 %
 476 %      Image *DuplicateImages(Image *images,const size_t number_duplicates,
 477 %        const char *scenes,ExceptionInfo *exception)
 478 %
 479 %  A description of each parameter follows:
 480 %
 481 %    o images: the image sequence.
 482 %
 483 %    o number_duplicates: duplicate the image sequence this number of times.
 484 %
 485 %    o scenes: This character string specifies which scenes to duplicate (e.g.
 486 %      1,3-5,-2-6,2).
 487 %
 488 %    o exception: return any errors or warnings in this structure.
 489 %
 490 */
 491 MagickExport Image *DuplicateImages(Image *images,
 492   const size_t number_duplicates,const char *scenes,ExceptionInfo *exception)
 493 {
 494   Image
 495     *clone_images,
 496     *duplicate_images;
 497
 498   register ssize_t
 499     i;
 500
 501   /*
 502     Duplicate images.
 503   */
 504   assert(images != (Image *) NULL);
 505   assert(images->signature == MagickSignature);
 506   assert(scenes != (char *) NULL);
 507   if (images->debug != MagickFalse)
 508     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 509   assert(exception != (ExceptionInfo *) NULL);
 510   assert(exception->signature == MagickSignature);
 511   duplicate_images=NewImageList();
 512   for (i=0; i < (ssize_t) number_duplicates; i++)
 513   {
 514     clone_images=CloneImages(images,scenes,exception);
 515     AppendImageToList(&duplicate_images,clone_images);
 516   }
 517   return(duplicate_images);
 518 }
 519 \f
 520 /*
 521 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 522 %                                                                             %
 523 %                                                                             %
 524 %                                                                             %
 525 %   G e t F i r s t I m a g e I n L i s t                                     %
 526 %                                                                             %
 527 %                                                                             %
 528 %                                                                             %
 529 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 530 %
 531 %  GetFirstImageInList() returns a pointer to the first image in the list.
 532 %
 533 %  The format of the GetFirstImageInList method is:
 534 %
 535 %      Image *GetFirstImageInList(const Image *images)
 536 %
 537 %  A description of each parameter follows:
 538 %
 539 %    o images: the image list.
 540 %
 541 */
 542 MagickExport Image *GetFirstImageInList(const Image *images)
 543 {
 544   register const Image
 545     *p;
 546
 547   if (images == (Image *) NULL)
 548     return((Image *) NULL);
 549   assert(images->signature == MagickSignature);
 550   for (p=images; p->previous != (Image *) NULL; p=p->previous) ;
 551   return((Image *) p);
 552 }
 553 \f
 554 /*
 555 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 556 %                                                                             %
 557 %                                                                             %
 558 %                                                                             %
 559 %   G e t I m a g e F r o m L i s t                                           %
 560 %                                                                             %
 561 %                                                                             %
 562 %                                                                             %
 563 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 564 %
 565 %  GetImageFromList() returns an image at the specified offset from the list.
 566 %
 567 %  The format of the GetImageFromList method is:
 568 %
 569 %      Image *GetImageFromList(const Image *images,const ssize_t index)
 570 %
 571 %  A description of each parameter follows:
 572 %
 573 %    o images: the image list.
 574 %
 575 %    o index: the position within the list.
 576 %
 577 */
 578 MagickExport Image *GetImageFromList(const Image *images,const ssize_t index)
 579 {
 580   register const Image
 581     *p;
 582
 583   register ssize_t
 584     i;
 585
 586   size_t
 587     length;
 588
 589   ssize_t
 590     offset;
 591
 592   if (images == (Image *) NULL)
 593     return((Image *) NULL);
 594   assert(images->signature == MagickSignature);
 595   if (images->debug != MagickFalse)
 596     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 597   for (p=images; p->previous != (Image *) NULL; p=p->previous) ;
 598   length=GetImageListLength(images);
 599   for (offset=index; offset < 0; offset+=(ssize_t) length) ;
 600   for (i=0; p != (Image *) NULL; p=p->next)
 601     if (i++ == (ssize_t) (offset % length))
 602       break;
 603   if (p == (Image *) NULL)
 604     return((Image *) NULL);
 605   return((Image *) p);
 606 }
 607 \f
 608 /*
 609 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 610 %                                                                             %
 611 %                                                                             %
 612 %                                                                             %
 613 %   G e t I m a g e I n d e x I n L i s t                                     %
 614 %                                                                             %
 615 %                                                                             %
 616 %                                                                             %
 617 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 618 %
 619 %  GetImageIndexInList() returns the offset in the list of the specified image.
 620 %
 621 %  The format of the GetImageIndexInList method is:
 622 %
 623 %      ssize_t GetImageIndexInList(const Image *images)
 624 %
 625 %  A description of each parameter follows:
 626 %
 627 %    o images: the image list.
 628 %
 629 */
 630 MagickExport ssize_t GetImageIndexInList(const Image *images)
 631 {
 632   register ssize_t
 633     i;
 634
 635   if (images == (const Image *) NULL)
 636     return(-1);
 637   assert(images->signature == MagickSignature);
 638   for (i=0; images->previous != (Image *) NULL; i++)
 639     images=images->previous;
 640   return(i);
 641 }
 642 \f
 643 /*
 644 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 645 %                                                                             %
 646 %                                                                             %
 647 %                                                                             %
 648 %   G e t I m a g e L i s t L e n g t h                                       %
 649 %                                                                             %
 650 %                                                                             %
 651 %                                                                             %
 652 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 653 %
 654 %  GetImageListLength() returns the length of the list (the number of images in
 655 %  the list).
 656 %
 657 %  The format of the GetImageListLength method is:
 658 %
 659 %      size_t GetImageListLength(const Image *images)
 660 %
 661 %  A description of each parameter follows:
 662 %
 663 %    o images: the image list.
 664 %
 665 */
 666 MagickExport size_t GetImageListLength(const Image *images)
 667 {
 668   register ssize_t
 669     i;
 670
 671   if (images == (Image *) NULL)
 672     return(0);
 673   assert(images->signature == MagickSignature);
 674   if (images->debug != MagickFalse)
 675     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 676   while (images->previous != (Image *) NULL)
 677     images=images->previous;
 678   for (i=0; images != (Image *) NULL; images=images->next)
 679     i++;
 680   return((size_t) i);
 681 }
 682 \f
 683 /*
 684 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 685 %                                                                             %
 686 %                                                                             %
 687 %                                                                             %
 688 %   G e t L a s t I m a g e I n L i s t                                       %
 689 %                                                                             %
 690 %                                                                             %
 691 %                                                                             %
 692 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 693 %
 694 %  GetLastImageInList() returns a pointer to the last image in the list.
 695 %
 696 %  The format of the GetLastImageInList method is:
 697 %
 698 %      Image *GetLastImageInList(const Image *images)
 699 %
 700 %  A description of each parameter follows:
 701 %
 702 %    o images: the image list.
 703 %
 704 */
 705 MagickExport Image *GetLastImageInList(const Image *images)
 706 {
 707   register const Image
 708     *p;
 709
 710   if (images == (Image *) NULL)
 711     return((Image *) NULL);
 712   assert(images->signature == MagickSignature);
 713   for (p=images; p->next != (Image *) NULL; p=p->next) ;
 714   return((Image *) p);
 715 }
 716 \f
 717 /*
 718 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 719 %                                                                             %
 720 %                                                                             %
 721 %                                                                             %
 722 %   G e t N e x t I m a g e I n L i s t                                       %
 723 %                                                                             %
 724 %                                                                             %
 725 %                                                                             %
 726 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 727 %
 728 %  GetNextImageInList() returns the next image in the list.
 729 %
 730 %  The format of the GetNextImageInList method is:
 731 %
 732 %      Image *GetNextImageInList(const Image *images)
 733 %
 734 %  A description of each parameter follows:
 735 %
 736 %    o images: the image list.
 737 %
 738 */
 739 MagickExport Image *GetNextImageInList(const Image *images)
 740 {
 741   if (images == (Image *) NULL)
 742     return((Image *) NULL);
 743   assert(images->signature == MagickSignature);
 744   if (images->debug != MagickFalse)
 745     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 746   return(images->next);
 747 }
 748 \f
 749 /*
 750 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 751 %                                                                             %
 752 %                                                                             %
 753 %                                                                             %
 754 %   G e t P r e v i o u s I m a g e I n L i s t                               %
 755 %                                                                             %
 756 %                                                                             %
 757 %                                                                             %
 758 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 759 %
 760 %  GetPreviousImageInList() returns the previous image in the list.
 761 %
 762 %  The format of the GetPreviousImageInList method is:
 763 %
 764 %      Image *GetPreviousImageInList(const Image *images)
 765 %
 766 %  A description of each parameter follows:
 767 %
 768 %    o images: the image list.
 769 %
 770 */
 771 MagickExport Image *GetPreviousImageInList(const Image *images)
 772 {
 773   if (images == (Image *) NULL)
 774     return((Image *) NULL);
 775   assert(images->signature == MagickSignature);
 776   return(images->previous);
 777 }
 778 \f
 779 /*
 780 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 781 %                                                                             %
 782 %                                                                             %
 783 %     I m a g e L i s t T o A r r a y                                         %
 784 %                                                                             %
 785 %                                                                             %
 786 %                                                                             %
 787 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 788 %
 789 %  ImageListToArray() is a convenience method that converts an image list to
 790 %  a sequential array.  For example,
 791 %
 792 %    group = ImageListToArray(images, exception);
 793 %    while (i = 0; group[i] != (Image *) NULL; i++)
 794 %      printf("%s\n", group[i]->filename);
 795 %    printf("%d images\n", i);
 796 %    group = RelinquishMagickMemory(group);
 797 %
 798 %  The format of the ImageListToArray method is:
 799 %
 800 %      Image **ImageListToArray(const Image *images,ExceptionInfo *exception)
 801 %
 802 %  A description of each parameter follows:
 803 %
 804 %    o image: the image list.
 805 %
 806 %    o exception: return any errors or warnings in this structure.
 807 %
 808 */
 809 MagickExport Image **ImageListToArray(const Image *images,
 810   ExceptionInfo *exception)
 811 {
 812   Image
 813     **group;
 814
 815   register ssize_t
 816     i;
 817
 818   if (images == (Image *) NULL)
 819     return((Image **) NULL);
 820   assert(images->signature == MagickSignature);
 821   if (images->debug != MagickFalse)
 822     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 823   group=(Image **) AcquireQuantumMemory((size_t) GetImageListLength(images)+1UL,
 824     sizeof(*group));
 825   if (group == (Image **) NULL)
 826     {
 827       (void) ThrowMagickException(exception,GetMagickModule(),
 828         ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
 829       return((Image **) NULL);
 830     }
 831   images=GetFirstImageInList(images);
 832   for (i=0; images != (Image *) NULL; images=images->next)
 833     group[i++]=(Image *) images;
 834   group[i]=(Image *) NULL;
 835   return(group);
 836 }
 837 \f
 838 /*
 839 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 840 %                                                                             %
 841 %                                                                             %
 842 %                                                                             %
 843 %   I n s e r t I m a g e I n L i s t                                         %
 844 %                                                                             %
 845 %                                                                             %
 846 %                                                                             %
 847 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 848 %
 849 %  InsertImageInList() inserts the second image or image list into the first
 850 %  image list immediately after the image pointed to.  The given image list
 851 %  pointer is unchanged unless previously empty.
 852 %
 853 %  The format of the InsertImageInList method is:
 854 %
 855 %      InsertImageInList(Image **images,Image *image)
 856 %
 857 %  A description of each parameter follows:
 858 %
 859 %    o images: the image list to insert into.
 860 %
 861 %    o image: the image list to insert.
 862 %
 863 */
 864 MagickExport void InsertImageInList(Image **images,Image *image)
 865 {
 866   Image
 867     *split;
 868
 869   assert(images != (Image **) NULL);
 870   assert(image != (Image *) NULL);
 871   assert(image->signature == MagickSignature);
 872   if (image->debug != MagickFalse)
 873     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 874   if ((*images) == (Image *) NULL)
 875     return;
 876   assert((*images)->signature == MagickSignature);
 877   split=SplitImageList(*images);
 878   AppendImageToList(images,image);
 879   AppendImageToList(images,split);
 880 }
 881 \f
 882 /*
 883 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 884 %                                                                             %
 885 %                                                                             %
 886 %                                                                             %
 887 %   N e w I m a g e L i s t                                                   %
 888 %                                                                             %
 889 %                                                                             %
 890 %                                                                             %
 891 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 892 %
 893 %  NewImageList() creates an empty image list.
 894 %
 895 %  The format of the NewImageList method is:
 896 %
 897 %      Image *NewImageList(void)
 898 %
 899 */
 900 MagickExport Image *NewImageList(void)
 901 {
 902   return((Image *) NULL);
 903 }
 904 \f
 905 /*
 906 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 907 %                                                                             %
 908 %                                                                             %
 909 %                                                                             %
 910 %   P r e p e n d I m a g e T o L i s t                                       %
 911 %                                                                             %
 912 %                                                                             %
 913 %                                                                             %
 914 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 915 %
 916 %  PrependImageToList() prepends the image to the beginning of the list.
 917 %
 918 %  The format of the PrependImageToList method is:
 919 %
 920 %      PrependImageToList(Image *images,Image *image)
 921 %
 922 %  A description of each parameter follows:
 923 %
 924 %    o images: the image list.
 925 %
 926 %    o image: the image.
 927 %
 928 */
 929 MagickExport void PrependImageToList(Image **images,Image *image)
 930 {
 931   AppendImageToList(&image,*images);
 932 }
 933 \f
 934 /*
 935 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 936 %                                                                             %
 937 %                                                                             %
 938 %                                                                             %
 939 %   R e m o v e I m a g e F r o m L i s t                                     %
 940 %                                                                             %
 941 %                                                                             %
 942 %                                                                             %
 943 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 944 %
 945 %  RemoveImageFromList() removes and returns the image pointed to.
 946 %
 947 %  The given image list pointer is set to point to the next image in list
 948 %  if it exists, otherwise it is set to the previous image, or NULL if list
 949 %  was emptied.
 950 %
 951 %  The format of the RemoveImageFromList method is:
 952 %
 953 %      Image *RemoveImageFromList(Image **images)
 954 %
 955 %  A description of each parameter follows:
 956 %
 957 %    o images: the image list.
 958 %
 959 */
 960 MagickExport Image *RemoveImageFromList(Image **images)
 961 {
 962   register Image
 963     *p;
 964
 965   assert(images != (Image **) NULL);
 966   if ((*images) == (Image *) NULL)
 967     return((Image *) NULL);
 968   assert((*images)->signature == MagickSignature);
 969   if ((*images)->debug != MagickFalse)
 970     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 971       (*images)->filename);
 972   p=(*images);
 973   if ((p->previous == (Image *) NULL) && (p->next == (Image *) NULL))
 974     *images=(Image *) NULL;
 975   else
 976     {
 977       if (p->previous != (Image *) NULL)
 978         {
 979           p->previous->next=p->next;
 980           *images=p->previous;
 981         }
 982       if (p->next != (Image *) NULL)
 983         {
 984           p->next->previous=p->previous;
 985           *images=p->next;
 986         }
 987       p->previous=(Image *) NULL;
 988       p->next=(Image *) NULL;
 989     }
 990   return(p);
 991 }
 992 \f
 993 /*
 994 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 995 %                                                                             %
 996 %                                                                             %
 997 %                                                                             %
 998 %   R e m o v e F i r s t I m a g e F r o m L i s t                           %
 999 %                                                                             %
1000 %                                                                             %
1001 %                                                                             %
1002 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1003 %
1004 %  RemoveFirstImageFromList() removes and returns the first image in the list.
1005 %
1006 %  If the given image list pointer pointed to the removed first image, it is
1007 %  set to the new first image of list, or NULL if list was emptied, otherwise
1008 %  it is left as is.
1009 %
1010 %  The format of the RemoveFirstImageFromList method is:
1011 %
1012 %      Image *RemoveFirstImageFromList(Image **images)
1013 %
1014 %  A description of each parameter follows:
1015 %
1016 %    o images: the image list.
1017 %
1018 */
1019 MagickExport Image *RemoveFirstImageFromList(Image **images)
1020 {
1021   Image
1022     *image;
1023
1024   assert(images != (Image **) NULL);
1025   if ((*images) == (Image *) NULL)
1026     return((Image *) NULL);
1027   assert((*images)->signature == MagickSignature);
1028   if ((*images)->debug != MagickFalse)
1029     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1030       (*images)->filename);
1031   image=(*images);
1032   while (image->previous != (Image *) NULL)
1033     image=image->previous;
1034   if (image == *images)
1035     *images=(*images)->next;
1036   if (image->next != (Image *) NULL)
1037     {
1038       image->next->previous=(Image *) NULL;
1039       image->next=(Image *) NULL;
1040     }
1041   return(image);
1042 }
1043 \f
1044 /*
1045 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1046 %                                                                             %
1047 %                                                                             %
1048 %                                                                             %
1049 %   R e m o v e L a s t I m a g e F r o m L i s t                             %
1050 %                                                                             %
1051 %                                                                             %
1052 %                                                                             %
1053 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1054 %
1055 %  RemoveLastImageFromList() removes and returns the last image from the list.
1056 %
1057 %  If the given image list pointer pointed to the removed last image, it is
1058 %  set to the new last image of list, or NULL if list was emptied, otherwise
1059 %  it is left as is.
1060 %
1061 %  The format of the RemoveLastImageFromList method is:
1062 %
1063 %      Image *RemoveLastImageFromList(Image **images)
1064 %
1065 %  A description of each parameter follows:
1066 %
1067 %    o images: the image list.
1068 %
1069 */
1070 MagickExport Image *RemoveLastImageFromList(Image **images)
1071 {
1072   Image
1073     *image;
1074
1075   assert(images != (Image **) NULL);
1076   if ((*images) == (Image *) NULL)
1077     return((Image *) NULL);
1078   assert((*images)->signature == MagickSignature);
1079   if ((*images)->debug != MagickFalse)
1080     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1081       (*images)->filename);
1082   image=(*images);
1083   while (image->next != (Image *) NULL)
1084     image=image->next;
1085   if (image == *images)
1086     *images=(*images)->previous;
1087   if (image->previous != (Image *) NULL)
1088     {
1089       image->previous->next=(Image *) NULL;
1090       image->previous=(Image *) NULL;
1091     }
1092   return(image);
1093 }
1094 \f
1095 /*
1096 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1097 %                                                                             %
1098 %                                                                             %
1099 %                                                                             %
1100 %   R e p l a c e I m a g e I n L i s t                                       %
1101 %                                                                             %
1102 %                                                                             %
1103 %                                                                             %
1104 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1105 %
1106 %  ReplaceImageInList() replaces an image in the list with the given image, or
1107 %  list of images.  Old image is destroyed.  The image list pointer is set to
1108 %  point to the first image of the inserted list of images.
1109 %
1110 %  The format of the ReplaceImageInList method is:
1111 %
1112 %      ReplaceImageInList(Image **images,Image *image)
1113 %
1114 %  A description of each parameter follows:
1115 %
1116 %    o images: the list and pointer to image to replace
1117 %
1118 %    o image: the image or image list replacing the original
1119 %
1120 */
1121 MagickExport void ReplaceImageInList(Image **images,Image *image)
1122 {
1123   assert(images != (Image **) NULL);
1124   assert(image != (Image *) NULL);
1125   assert(image->signature == MagickSignature);
1126   if (image->debug != MagickFalse)
1127     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1128   if ((*images) == (Image *) NULL)
1129     return;
1130   assert((*images)->signature == MagickSignature);
1131
1132   /* link next pointer */
1133   image=GetLastImageInList(image);
1134   image->next=(*images)->next;
1135   if (image->next != (Image *) NULL)
1136     image->next->previous=image;
1137
1138   /* link previous pointer - set image position to first replacement image */
1139   image=GetFirstImageInList(image);
1140   image->previous=(*images)->previous;
1141   if (image->previous != (Image *) NULL)
1142     image->previous->next=image;
1143
1144   /* destroy replaced image */
1145   (void) DestroyImage(*images);
1146   (*images)=image;
1147 }
1148 \f
1149 /*
1150 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1151 %                                                                             %
1152 %                                                                             %
1153 %                                                                             %
1154 %   R e p l a c e I m a g e I n L i s t R e t u r n L a s t                   %
1155 %                                                                             %
1156 %                                                                             %
1157 %                                                                             %
1158 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1159 %
1160 %  ReplaceImageInListReturnLast() is exactly as ReplaceImageInList() except
1161 %  the image pointer is set to the last image in the list.
1162 %
1163 %  This allows you to simply use 'next' to go to the image that follows the
1164 %  just replaced image.
1165 %
1166 %  The format of the ReplaceImageInList method is:
1167 %
1168 %      ReplaceImageInListReturnLast(Image **images,Image *image)
1169 %
1170 %  A description of each parameter follows:
1171 %
1172 %    o images: the list and pointer to image to replace
1173 %
1174 %    o image: the image or image list replacing the original
1175 %
1176 */
1177 MagickExport void ReplaceImageInListReturnLast(Image **images,Image *image)
1178 {
1179   assert(images != (Image **) NULL);
1180   assert(image != (Image *) NULL);
1181   assert(image->signature == MagickSignature);
1182   if (image->debug != MagickFalse)
1183     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1184   if ((*images) == (Image *) NULL)
1185     return;
1186   assert((*images)->signature == MagickSignature);
1187
1188   /* link previous pointer */
1189   image=GetFirstImageInList(image);
1190   image->previous=(*images)->previous;
1191   if (image->previous != (Image *) NULL)
1192     image->previous->next=image;
1193
1194   /* link next pointer - set image position to last replacement image */
1195   image=GetLastImageInList(image);
1196   image->next=(*images)->next;
1197   if (image->next != (Image *) NULL)
1198     image->next->previous=image;
1199
1200   /* destroy replaced image */
1201   (void) DestroyImage(*images);
1202   (*images)=image;
1203 }
1204 \f
1205 /*
1206 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1207 %                                                                             %
1208 %                                                                             %
1209 %                                                                             %
1210 %   R e v e r s e I m a g e L i s t                                           %
1211 %                                                                             %
1212 %                                                                             %
1213 %                                                                             %
1214 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1215 %
1216 %  ReverseImageList() reverses the order of an image list.
1217 %  The list pointer is reset to that start of the re-ordered list.
1218 %
1219 %  The format of the ReverseImageList method is:
1220 %
1221 %      void ReverseImageList(Image **images)
1222 %
1223 %  A description of each parameter follows:
1224 %
1225 %    o images: the image list.
1226 %
1227 */
1228 MagickExport void ReverseImageList(Image **images)
1229 {
1230   Image
1231     *next;
1232
1233   register Image
1234     *p;
1235
1236   assert(images != (Image **) NULL);
1237   if ((*images) == (Image *) NULL)
1238     return;
1239   assert((*images)->signature == MagickSignature);
1240   if ((*images)->debug != MagickFalse)
1241     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1242       (*images)->filename);
1243   for (p=(*images); p->next != (Image *) NULL; p=p->next) ;
1244   *images=p;
1245   for ( ; p != (Image *) NULL; p=p->next)
1246   {
1247     next=p->next;
1248     p->next=p->previous;
1249     p->previous=next;
1250   }
1251 }
1252 \f
1253 /*
1254 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1255 %                                                                             %
1256 %                                                                             %
1257 %                                                                             %
1258 %   S p l i c e I m a g e I n t o L i s t                                     %
1259 %                                                                             %
1260 %                                                                             %
1261 %                                                                             %
1262 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1263 %
1264 %  SpliceImageIntoList() removes 'length' images from the list and replaces
1265 %  them with the specified splice. Removed images are returned.
1266 %
1267 %  The format of the SpliceImageIntoList method is:
1268 %
1269 %      SpliceImageIntoList(Image **images,const size_t,
1270 %        const Image *splice)
1271 %
1272 %  A description of each parameter follows:
1273 %
1274 %    o images: the image list.
1275 %
1276 %    o length: the length of the image list to remove.
1277 %
1278 %    o splice: Replace the removed image list with this list.
1279 %
1280 */
1281 MagickExport Image *SpliceImageIntoList(Image **images,
1282   const size_t length,const Image *splice)
1283 {
1284   Image
1285     *image,
1286     *split;
1287
1288   register size_t
1289     i;
1290
1291   assert(images != (Image **) NULL);
1292   assert(splice != (Image *) NULL);
1293   assert(splice->signature == MagickSignature);
1294   if ((*images) == (Image *) NULL)
1295     return((Image *) NULL);
1296   assert((*images)->signature == MagickSignature);
1297   if ((*images)->debug != MagickFalse)
1298     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1299       (*images)->filename);
1300   split=SplitImageList(*images);
1301   AppendImageToList(images,splice);
1302   image=(Image *) NULL;
1303   for (i=0; (i < length) && (split != (Image *) NULL); i++)
1304     AppendImageToList(&image,RemoveImageFromList(&split));
1305   AppendImageToList(images,split);
1306   return(image);
1307 }
1308 \f
1309 /*
1310 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1311 %                                                                             %
1312 %                                                                             %
1313 %                                                                             %
1314 %   S p l i t I m a g e L i s t                                               %
1315 %                                                                             %
1316 %                                                                             %
1317 %                                                                             %
1318 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1319 %
1320 %  SplitImageList() splits an image into two lists, after given image
1321 %  The list that was split off is returned, which may be empty.
1322 %
1323 %  The format of the SplitImageList method is:
1324 %
1325 %      Image *SplitImageList(Image *images)
1326 %
1327 %  A description of each parameter follows:
1328 %
1329 %    o images: the image list.
1330 %
1331 */
1332 MagickExport Image *SplitImageList(Image *images)
1333 {
1334   if ((images == (Image *) NULL) || (images->next == (Image *) NULL))
1335     return((Image *) NULL);
1336   images=images->next;
1337   images->previous->next=(Image *) NULL;
1338   images->previous=(Image *) NULL;
1339   return(images);
1340 }
1341 \f
1342 /*
1343 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1344 %                                                                             %
1345 %                                                                             %
1346 %                                                                             %
1347 +   S y n c I m a g e L i s t                                                 %
1348 %                                                                             %
1349 %                                                                             %
1350 %                                                                             %
1351 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1352 %
1353 %  SyncImageList() synchronizes the scene numbers in an image list.
1354 %
1355 %  The format of the SyncImageList method is:
1356 %
1357 %      void SyncImageList(Image *images)
1358 %
1359 %  A description of each parameter follows:
1360 %
1361 %    o images: the image list.
1362 %
1363 */
1364 MagickExport void SyncImageList(Image *images)
1365 {
1366   register Image
1367     *p,
1368     *q;
1369
1370   if (images == (Image *) NULL)
1371     return;
1372   assert(images->signature == MagickSignature);
1373   for (p=images; p != (Image *) NULL; p=p->next)
1374   {
1375     for (q=p->next; q != (Image *) NULL; q=q->next)
1376       if (p->scene == q->scene)
1377         break;
1378     if (q != (Image *) NULL)
1379       break;
1380   }
1381   if (p == (Image *) NULL)
1382     return;
1383   for (p=images->next; p != (Image *) NULL; p=p->next)
1384     p->scene=p->previous->scene+1;
1385 }
1386 \f
1387 /*
1388 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1389 %                                                                             %
1390 %                                                                             %
1391 %                                                                             %
1392 +   S y n c N e x t I m a g e I n L i s t                                     %
1393 %                                                                             %
1394 %                                                                             %
1395 %                                                                             %
1396 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1397 %
1398 %  SyncNextImageInList() returns the next image in the list after the blob
1399 %  referenced is synchronized with the current image.
1400 %
1401 %  The format of the SyncNextImageInList method is:
1402 %
1403 %      Image *SyncNextImageInList(const Image *images)
1404 %
1405 %  A description of each parameter follows:
1406 %
1407 %    o images: the image list.
1408 %
1409 */
1410 MagickExport Image *SyncNextImageInList(const Image *images)
1411 {
1412   if (images == (Image *) NULL)
1413     return((Image *) NULL);
1414   assert(images->signature == MagickSignature);
1415   if (images->next == (Image *) NULL)
1416     return((Image *) NULL);
1417   if (images->blob != images->next->blob)
1418     {
1419       DestroyBlob(images->next);
1420       images->next->blob=ReferenceBlob(images->blob);
1421     }
1422   images->next->compression=images->compression;
1423   images->next->endian=images->endian;
1424   return(images->next);
1425 }