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() duplicates 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() duplicates 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 duplicate
 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     *duplicate_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   duplicate_list=(MagickBooleanType *) AcquireQuantumMemory(length,
 370     sizeof(*duplicate_list));
 371   if (duplicate_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     duplicate_list[i]=MagickFalse;
 380   /*
 381     Note which images will be duplicated, avoid duplicate duplicated
 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         duplicate_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 (duplicate_list[i] != MagickFalse)
 414       DeleteImageFromList(images);
 415
 416   }
 417   (void) RelinquishMagickMemory(duplicate_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 %  If the referenced images are in the reverse order, that range will be
 475 %  completely ignored, unlike CloneImages().
 476 %
 477 %  The format of the DuplicateImages method is:
 478 %
 479 %      Image *DuplicateImages(Image *images,const char *scenes,
 480 %        ExceptionInfo *exception)
 481 %
 482 %  A description of each parameter follows:
 483 %
 484 %    o images: the image sequence.
 485 %
 486 %    o scenes: This character string specifies the count and which scenes to
 487 %      duplicate (e.g. 2,1,3-5,-2-6,2).
 488 %
 489 %    o exception: return any errors or warnings in this structure.
 490 %
 491 */
 492 MagickExport Image *DuplicateImages(Image *images,const char *scenes,
 493   ExceptionInfo *exception)
 494 {
 495   char
 496     *p;
 497
 498   Image
 499     *clone_images,
 500     *duplicate_images;
 501
 502   ssize_t
 503     count;
 504
 505   /*
 506     Duplicate images.
 507   */
 508   assert(images != (Image *) NULL);
 509   assert(images->signature == MagickSignature);
 510   assert(scenes != (char *) NULL);
 511   if (images->debug != MagickFalse)
 512     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 513   assert(exception != (ExceptionInfo *) NULL);
 514   assert(exception->signature == MagickSignature);
 515   p=(char *) scenes;
 516   while ((isspace((int)*p) != 0) || (*p == ','))
 517     p++;
 518   count=(ssize_t) strtol(p,&p,10);
 519   duplicate_images=NewImageList();
 520   while (count-- > 0)
 521   {
 522     clone_images=CloneImages(images,p,exception);
 523     AppendImageToList(&duplicate_images,clone_images);
 524   }
 525   if (duplicate_images == (Image *) NULL)
 526     duplicate_images=CloneImages(images,"0",exception);
 527   return(duplicate_images);
 528 }
 529 \f
 530 /*
 531 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 532 %                                                                             %
 533 %                                                                             %
 534 %                                                                             %
 535 %   G e t F i r s t I m a g e I n L i s t                                     %
 536 %                                                                             %
 537 %                                                                             %
 538 %                                                                             %
 539 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 540 %
 541 %  GetFirstImageInList() returns a pointer to the first image in the list.
 542 %
 543 %  The format of the GetFirstImageInList method is:
 544 %
 545 %      Image *GetFirstImageInList(const Image *images)
 546 %
 547 %  A description of each parameter follows:
 548 %
 549 %    o images: the image list.
 550 %
 551 */
 552 MagickExport Image *GetFirstImageInList(const Image *images)
 553 {
 554   register const Image
 555     *p;
 556
 557   if (images == (Image *) NULL)
 558     return((Image *) NULL);
 559   assert(images->signature == MagickSignature);
 560   for (p=images; p->previous != (Image *) NULL; p=p->previous) ;
 561   return((Image *) p);
 562 }
 563 \f
 564 /*
 565 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 566 %                                                                             %
 567 %                                                                             %
 568 %                                                                             %
 569 %   G e t I m a g e F r o m L i s t                                           %
 570 %                                                                             %
 571 %                                                                             %
 572 %                                                                             %
 573 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 574 %
 575 %  GetImageFromList() returns an image at the specified offset from the list.
 576 %
 577 %  The format of the GetImageFromList method is:
 578 %
 579 %      Image *GetImageFromList(const Image *images,const ssize_t index)
 580 %
 581 %  A description of each parameter follows:
 582 %
 583 %    o images: the image list.
 584 %
 585 %    o index: the position within the list.
 586 %
 587 */
 588 MagickExport Image *GetImageFromList(const Image *images,const ssize_t index)
 589 {
 590   register const Image
 591     *p;
 592
 593   register ssize_t
 594     i;
 595
 596   size_t
 597     length;
 598
 599   ssize_t
 600     offset;
 601
 602   if (images == (Image *) NULL)
 603     return((Image *) NULL);
 604   assert(images->signature == MagickSignature);
 605   if (images->debug != MagickFalse)
 606     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 607   for (p=images; p->previous != (Image *) NULL; p=p->previous) ;
 608   length=GetImageListLength(images);
 609   for (offset=index; offset < 0; offset+=(ssize_t) length) ;
 610   for (i=0; p != (Image *) NULL; p=p->next)
 611     if (i++ == (ssize_t) (offset % length))
 612       break;
 613   if (p == (Image *) NULL)
 614     return((Image *) NULL);
 615   return((Image *) p);
 616 }
 617 \f
 618 /*
 619 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 620 %                                                                             %
 621 %                                                                             %
 622 %                                                                             %
 623 %   G e t I m a g e I n d e x I n L i s t                                     %
 624 %                                                                             %
 625 %                                                                             %
 626 %                                                                             %
 627 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 628 %
 629 %  GetImageIndexInList() returns the offset in the list of the specified image.
 630 %
 631 %  The format of the GetImageIndexInList method is:
 632 %
 633 %      ssize_t GetImageIndexInList(const Image *images)
 634 %
 635 %  A description of each parameter follows:
 636 %
 637 %    o images: the image list.
 638 %
 639 */
 640 MagickExport ssize_t GetImageIndexInList(const Image *images)
 641 {
 642   register ssize_t
 643     i;
 644
 645   if (images == (const Image *) NULL)
 646     return(-1);
 647   assert(images->signature == MagickSignature);
 648   for (i=0; images->previous != (Image *) NULL; i++)
 649     images=images->previous;
 650   return(i);
 651 }
 652 \f
 653 /*
 654 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 655 %                                                                             %
 656 %                                                                             %
 657 %                                                                             %
 658 %   G e t I m a g e L i s t L e n g t h                                       %
 659 %                                                                             %
 660 %                                                                             %
 661 %                                                                             %
 662 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 663 %
 664 %  GetImageListLength() returns the length of the list (the number of images in
 665 %  the list).
 666 %
 667 %  The format of the GetImageListLength method is:
 668 %
 669 %      size_t GetImageListLength(const Image *images)
 670 %
 671 %  A description of each parameter follows:
 672 %
 673 %    o images: the image list.
 674 %
 675 */
 676 MagickExport size_t GetImageListLength(const Image *images)
 677 {
 678   register ssize_t
 679     i;
 680
 681   if (images == (Image *) NULL)
 682     return(0);
 683   assert(images->signature == MagickSignature);
 684   if (images->debug != MagickFalse)
 685     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 686   while (images->previous != (Image *) NULL)
 687     images=images->previous;
 688   for (i=0; images != (Image *) NULL; images=images->next)
 689     i++;
 690   return((size_t) i);
 691 }
 692 \f
 693 /*
 694 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 695 %                                                                             %
 696 %                                                                             %
 697 %                                                                             %
 698 %   G e t L a s t I m a g e I n L i s t                                       %
 699 %                                                                             %
 700 %                                                                             %
 701 %                                                                             %
 702 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 703 %
 704 %  GetLastImageInList() returns a pointer to the last image in the list.
 705 %
 706 %  The format of the GetLastImageInList method is:
 707 %
 708 %      Image *GetLastImageInList(const Image *images)
 709 %
 710 %  A description of each parameter follows:
 711 %
 712 %    o images: the image list.
 713 %
 714 */
 715 MagickExport Image *GetLastImageInList(const Image *images)
 716 {
 717   register const Image
 718     *p;
 719
 720   if (images == (Image *) NULL)
 721     return((Image *) NULL);
 722   assert(images->signature == MagickSignature);
 723   for (p=images; p->next != (Image *) NULL; p=p->next) ;
 724   return((Image *) p);
 725 }
 726 \f
 727 /*
 728 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 729 %                                                                             %
 730 %                                                                             %
 731 %                                                                             %
 732 %   G e t N e x t I m a g e I n L i s t                                       %
 733 %                                                                             %
 734 %                                                                             %
 735 %                                                                             %
 736 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 737 %
 738 %  GetNextImageInList() returns the next image in the list.
 739 %
 740 %  The format of the GetNextImageInList method is:
 741 %
 742 %      Image *GetNextImageInList(const Image *images)
 743 %
 744 %  A description of each parameter follows:
 745 %
 746 %    o images: the image list.
 747 %
 748 */
 749 MagickExport Image *GetNextImageInList(const Image *images)
 750 {
 751   if (images == (Image *) NULL)
 752     return((Image *) NULL);
 753   assert(images->signature == MagickSignature);
 754   if (images->debug != MagickFalse)
 755     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 756   return(images->next);
 757 }
 758 \f
 759 /*
 760 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 761 %                                                                             %
 762 %                                                                             %
 763 %                                                                             %
 764 %   G e t P r e v i o u s I m a g e I n L i s t                               %
 765 %                                                                             %
 766 %                                                                             %
 767 %                                                                             %
 768 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 769 %
 770 %  GetPreviousImageInList() returns the previous image in the list.
 771 %
 772 %  The format of the GetPreviousImageInList method is:
 773 %
 774 %      Image *GetPreviousImageInList(const Image *images)
 775 %
 776 %  A description of each parameter follows:
 777 %
 778 %    o images: the image list.
 779 %
 780 */
 781 MagickExport Image *GetPreviousImageInList(const Image *images)
 782 {
 783   if (images == (Image *) NULL)
 784     return((Image *) NULL);
 785   assert(images->signature == MagickSignature);
 786   return(images->previous);
 787 }
 788 \f
 789 /*
 790 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 791 %                                                                             %
 792 %                                                                             %
 793 %     I m a g e L i s t T o A r r a y                                         %
 794 %                                                                             %
 795 %                                                                             %
 796 %                                                                             %
 797 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 798 %
 799 %  ImageListToArray() is a convenience method that converts an image list to
 800 %  a sequential array.  For example,
 801 %
 802 %    group = ImageListToArray(images, exception);
 803 %    while (i = 0; group[i] != (Image *) NULL; i++)
 804 %      printf("%s\n", group[i]->filename);
 805 %    printf("%d images\n", i);
 806 %    group = RelinquishMagickMemory(group);
 807 %
 808 %  The format of the ImageListToArray method is:
 809 %
 810 %      Image **ImageListToArray(const Image *images,ExceptionInfo *exception)
 811 %
 812 %  A description of each parameter follows:
 813 %
 814 %    o image: the image list.
 815 %
 816 %    o exception: return any errors or warnings in this structure.
 817 %
 818 */
 819 MagickExport Image **ImageListToArray(const Image *images,
 820   ExceptionInfo *exception)
 821 {
 822   Image
 823     **group;
 824
 825   register ssize_t
 826     i;
 827
 828   if (images == (Image *) NULL)
 829     return((Image **) NULL);
 830   assert(images->signature == MagickSignature);
 831   if (images->debug != MagickFalse)
 832     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 833   group=(Image **) AcquireQuantumMemory((size_t) GetImageListLength(images)+1UL,
 834     sizeof(*group));
 835   if (group == (Image **) NULL)
 836     {
 837       (void) ThrowMagickException(exception,GetMagickModule(),
 838         ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
 839       return((Image **) NULL);
 840     }
 841   images=GetFirstImageInList(images);
 842   for (i=0; images != (Image *) NULL; images=images->next)
 843     group[i++]=(Image *) images;
 844   group[i]=(Image *) NULL;
 845   return(group);
 846 }
 847 \f
 848 /*
 849 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 850 %                                                                             %
 851 %                                                                             %
 852 %                                                                             %
 853 %   I n s e r t I m a g e I n L i s t                                         %
 854 %                                                                             %
 855 %                                                                             %
 856 %                                                                             %
 857 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 858 %
 859 %  InsertImageInList() inserts the second image or image list into the first
 860 %  image list immediately after the image pointed to.  The given image list
 861 %  pointer is unchanged unless previously empty.
 862 %
 863 %  The format of the InsertImageInList method is:
 864 %
 865 %      InsertImageInList(Image **images,Image *image)
 866 %
 867 %  A description of each parameter follows:
 868 %
 869 %    o images: the image list to insert into.
 870 %
 871 %    o image: the image list to insert.
 872 %
 873 */
 874 MagickExport void InsertImageInList(Image **images,Image *image)
 875 {
 876   Image
 877     *split;
 878
 879   assert(images != (Image **) NULL);
 880   assert(image != (Image *) NULL);
 881   assert(image->signature == MagickSignature);
 882   if (image->debug != MagickFalse)
 883     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 884   if ((*images) == (Image *) NULL)
 885     return;
 886   assert((*images)->signature == MagickSignature);
 887   split=SplitImageList(*images);
 888   AppendImageToList(images,image);
 889   AppendImageToList(images,split);
 890 }
 891 \f
 892 /*
 893 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 894 %                                                                             %
 895 %                                                                             %
 896 %                                                                             %
 897 %   N e w I m a g e L i s t                                                   %
 898 %                                                                             %
 899 %                                                                             %
 900 %                                                                             %
 901 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 902 %
 903 %  NewImageList() creates an empty image list.
 904 %
 905 %  The format of the NewImageList method is:
 906 %
 907 %      Image *NewImageList(void)
 908 %
 909 */
 910 MagickExport Image *NewImageList(void)
 911 {
 912   return((Image *) NULL);
 913 }
 914 \f
 915 /*
 916 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 917 %                                                                             %
 918 %                                                                             %
 919 %                                                                             %
 920 +   P a g e I n d e x I m a g e L i s t                                       %
 921 %                                                                             %
 922 %                                                                             %
 923 %                                                                             %
 924 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 925 %
 926 %  PageIndexImageList() synchronizes the page_index and page_total values
 927 %  in the image list.
 928 %
 929 %  These values are used by InterpretImageProperties() to set %p and %n
 930 %  percent escapes. The value is preserved, even if the image is later removed
 931 %  from the list using RemoveFirstImageFromList() for individual image
 932 %  processing.
 933 %
 934 %  The format of the PageIndexImageList method is:
 935 %
 936 %      void PageIndexImageList(Image *images)
 937 %
 938 %  A description of each parameter follows:
 939 %
 940 %    o images: the image list.
 941 %
 942 */
 943 MagickExport void PageIndexImageList(Image *images)
 944 {
 945   register ssize_t
 946     p,n;
 947
 948   if (images == (Image *) NULL)
 949     return;
 950   assert(images->signature == MagickSignature);
 951   if (images->debug != MagickFalse)
 952     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",images->filename);
 953
 954   /* find start for image counting */
 955   while (images->previous != (Image *) NULL)
 956     images=images->previous;
 957
 958   /* count up images - find end */
 959   n=1;
 960   while (images->next != (Image *) NULL)
 961     images=images->next, n++;
 962
 963   /* set page_index and page_total attributes */
 964   p=n-1;
 965   for (; images != (Image *) NULL; images=images->previous)
 966     images->page_index=p--, images->page_total=(size_t) n;
 967 }
 968 \f
 969 /*
 970 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 971 %                                                                             %
 972 %                                                                             %
 973 %                                                                             %
 974 %   P r e p e n d I m a g e T o L i s t                                       %
 975 %                                                                             %
 976 %                                                                             %
 977 %                                                                             %
 978 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 979 %
 980 %  PrependImageToList() prepends the image to the beginning of the list.
 981 %
 982 %  The format of the PrependImageToList method is:
 983 %
 984 %      PrependImageToList(Image *images,Image *image)
 985 %
 986 %  A description of each parameter follows:
 987 %
 988 %    o images: the image list.
 989 %
 990 %    o image: the image.
 991 %
 992 */
 993 MagickExport void PrependImageToList(Image **images,Image *image)
 994 {
 995   AppendImageToList(&image,*images);
 996 }
 997 \f
 998 /*
 999 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1000 %                                                                             %
1001 %                                                                             %
1002 %                                                                             %
1003 %   R e m o v e I m a g e F r o m L i s t                                     %
1004 %                                                                             %
1005 %                                                                             %
1006 %                                                                             %
1007 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1008 %
1009 %  RemoveImageFromList() removes and returns the image pointed to.
1010 %
1011 %  The given image list pointer is set to point to the next image in list
1012 %  if it exists, otherwise it is set to the previous image, or NULL if list
1013 %  was emptied.
1014 %
1015 %  The format of the RemoveImageFromList method is:
1016 %
1017 %      Image *RemoveImageFromList(Image **images)
1018 %
1019 %  A description of each parameter follows:
1020 %
1021 %    o images: the image list.
1022 %
1023 */
1024 MagickExport Image *RemoveImageFromList(Image **images)
1025 {
1026   register Image
1027     *p;
1028
1029   assert(images != (Image **) NULL);
1030   if ((*images) == (Image *) NULL)
1031     return((Image *) NULL);
1032   assert((*images)->signature == MagickSignature);
1033   if ((*images)->debug != MagickFalse)
1034     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1035       (*images)->filename);
1036   p=(*images);
1037   if ((p->previous == (Image *) NULL) && (p->next == (Image *) NULL))
1038     *images=(Image *) NULL;
1039   else
1040     {
1041       if (p->previous != (Image *) NULL)
1042         {
1043           p->previous->next=p->next;
1044           *images=p->previous;
1045         }
1046       if (p->next != (Image *) NULL)
1047         {
1048           p->next->previous=p->previous;
1049           *images=p->next;
1050         }
1051       p->previous=(Image *) NULL;
1052       p->next=(Image *) NULL;
1053     }
1054   return(p);
1055 }
1056 \f
1057 /*
1058 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1059 %                                                                             %
1060 %                                                                             %
1061 %                                                                             %
1062 %   R e m o v e F i r s t I m a g e F r o m L i s t                           %
1063 %                                                                             %
1064 %                                                                             %
1065 %                                                                             %
1066 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1067 %
1068 %  RemoveFirstImageFromList() removes and returns the first image in the list.
1069 %
1070 %  If the given image list pointer pointed to the removed first image, it is
1071 %  set to the new first image of list, or NULL if list was emptied, otherwise
1072 %  it is left as is.
1073 %
1074 %  The format of the RemoveFirstImageFromList method is:
1075 %
1076 %      Image *RemoveFirstImageFromList(Image **images)
1077 %
1078 %  A description of each parameter follows:
1079 %
1080 %    o images: the image list.
1081 %
1082 */
1083 MagickExport Image *RemoveFirstImageFromList(Image **images)
1084 {
1085   Image
1086     *image;
1087
1088   assert(images != (Image **) NULL);
1089   if ((*images) == (Image *) NULL)
1090     return((Image *) NULL);
1091   assert((*images)->signature == MagickSignature);
1092   if ((*images)->debug != MagickFalse)
1093     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1094       (*images)->filename);
1095   image=(*images);
1096   while (image->previous != (Image *) NULL)
1097     image=image->previous;
1098   if (image == *images)
1099     *images=(*images)->next;
1100   if (image->next != (Image *) NULL)
1101     {
1102       image->next->previous=(Image *) NULL;
1103       image->next=(Image *) NULL;
1104     }
1105   return(image);
1106 }
1107 \f
1108 /*
1109 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1110 %                                                                             %
1111 %                                                                             %
1112 %                                                                             %
1113 %   R e m o v e L a s t I m a g e F r o m L i s t                             %
1114 %                                                                             %
1115 %                                                                             %
1116 %                                                                             %
1117 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1118 %
1119 %  RemoveLastImageFromList() removes and returns the last image from the list.
1120 %
1121 %  If the given image list pointer pointed to the removed last image, it is
1122 %  set to the new last image of list, or NULL if list was emptied, otherwise
1123 %  it is left as is.
1124 %
1125 %  The format of the RemoveLastImageFromList method is:
1126 %
1127 %      Image *RemoveLastImageFromList(Image **images)
1128 %
1129 %  A description of each parameter follows:
1130 %
1131 %    o images: the image list.
1132 %
1133 */
1134 MagickExport Image *RemoveLastImageFromList(Image **images)
1135 {
1136   Image
1137     *image;
1138
1139   assert(images != (Image **) NULL);
1140   if ((*images) == (Image *) NULL)
1141     return((Image *) NULL);
1142   assert((*images)->signature == MagickSignature);
1143   if ((*images)->debug != MagickFalse)
1144     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1145       (*images)->filename);
1146   image=(*images);
1147   while (image->next != (Image *) NULL)
1148     image=image->next;
1149   if (image == *images)
1150     *images=(*images)->previous;
1151   if (image->previous != (Image *) NULL)
1152     {
1153       image->previous->next=(Image *) NULL;
1154       image->previous=(Image *) NULL;
1155     }
1156   return(image);
1157 }
1158 \f
1159 /*
1160 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1161 %                                                                             %
1162 %                                                                             %
1163 %                                                                             %
1164 %   R e p l a c e I m a g e I n L i s t                                       %
1165 %                                                                             %
1166 %                                                                             %
1167 %                                                                             %
1168 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1169 %
1170 %  ReplaceImageInList() replaces an image in the list. Old image is destroyed.
1171 %  The given image list pointer is set to point to the just inserted image.
1172 %
1173 %  The format of the ReplaceImageInList method is:
1174 %
1175 %      ReplaceImageInList(Image **images,Image *image)
1176 %
1177 %  A description of each parameter follows:
1178 %
1179 %    o images: the image list.
1180 %
1181 %    o image: the image.
1182 %
1183 */
1184 MagickExport void ReplaceImageInList(Image **images,Image *image)
1185 {
1186   assert(images != (Image **) NULL);
1187   assert(image != (Image *) NULL);
1188   assert(image->signature == MagickSignature);
1189   if (image->debug != MagickFalse)
1190     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1191   if ((*images) == (Image *) NULL)
1192     return;
1193   assert((*images)->signature == MagickSignature);
1194   for ( ; image->next != (Image *) NULL; image=image->next) ;
1195   image->next=(*images)->next;
1196   if (image->next != (Image *) NULL)
1197     image->next->previous=image;
1198   for ( ; image->previous != (Image *) NULL; image=image->previous) ;
1199   image->previous=(*images)->previous;
1200   if (image->previous != (Image *) NULL)
1201     image->previous->next=image;
1202   (void) DestroyImage(*images);
1203   (*images)=image;
1204 }
1205 \f
1206 /*
1207 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1208 %                                                                             %
1209 %                                                                             %
1210 %                                                                             %
1211 %   R e v e r s e I m a g e L i s t                                           %
1212 %                                                                             %
1213 %                                                                             %
1214 %                                                                             %
1215 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1216 %
1217 %  ReverseImageList() reverses the order of an image list.
1218 %  The list pointer is reset to that start of the re-ordered list.
1219 %
1220 %  The format of the ReverseImageList method is:
1221 %
1222 %      void ReverseImageList(Image **images)
1223 %
1224 %  A description of each parameter follows:
1225 %
1226 %    o images: the image list.
1227 %
1228 */
1229 MagickExport void ReverseImageList(Image **images)
1230 {
1231   Image
1232     *next;
1233
1234   register Image
1235     *p;
1236
1237   assert(images != (Image **) NULL);
1238   if ((*images) == (Image *) NULL)
1239     return;
1240   assert((*images)->signature == MagickSignature);
1241   if ((*images)->debug != MagickFalse)
1242     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1243       (*images)->filename);
1244   for (p=(*images); p->next != (Image *) NULL; p=p->next) ;
1245   *images=p;
1246   for ( ; p != (Image *) NULL; p=p->next)
1247   {
1248     next=p->next;
1249     p->next=p->previous;
1250     p->previous=next;
1251   }
1252 }
1253 \f
1254 /*
1255 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1256 %                                                                             %
1257 %                                                                             %
1258 %                                                                             %
1259 %   S p l i c e I m a g e I n t o L i s t                                     %
1260 %                                                                             %
1261 %                                                                             %
1262 %                                                                             %
1263 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1264 %
1265 %  SpliceImageIntoList() removes 'length' images from the list and replaces
1266 %  them with the specified splice. Removed images are returned.
1267 %
1268 %  The format of the SpliceImageIntoList method is:
1269 %
1270 %      SpliceImageIntoList(Image **images,const size_t,
1271 %        const Image *splice)
1272 %
1273 %  A description of each parameter follows:
1274 %
1275 %    o images: the image list.
1276 %
1277 %    o length: the length of the image list to remove.
1278 %
1279 %    o splice: Replace the removed image list with this list.
1280 %
1281 */
1282 MagickExport Image *SpliceImageIntoList(Image **images,
1283   const size_t length,const Image *splice)
1284 {
1285   Image
1286     *image,
1287     *split;
1288
1289   register size_t
1290     i;
1291
1292   assert(images != (Image **) NULL);
1293   assert(splice != (Image *) NULL);
1294   assert(splice->signature == MagickSignature);
1295   if ((*images) == (Image *) NULL)
1296     return((Image *) NULL);
1297   assert((*images)->signature == MagickSignature);
1298   if ((*images)->debug != MagickFalse)
1299     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
1300       (*images)->filename);
1301   split=SplitImageList(*images);
1302   AppendImageToList(images,splice);
1303   image=(Image *) NULL;
1304   for (i=0; (i < length) && (split != (Image *) NULL); i++)
1305     AppendImageToList(&image,RemoveImageFromList(&split));
1306   AppendImageToList(images,split);
1307   return(image);
1308 }
1309 \f
1310 /*
1311 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1312 %                                                                             %
1313 %                                                                             %
1314 %                                                                             %
1315 %   S p l i t I m a g e L i s t                                               %
1316 %                                                                             %
1317 %                                                                             %
1318 %                                                                             %
1319 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1320 %
1321 %  SplitImageList() splits an image into two lists, after given image
1322 %  The list that was split off is returned, which may be empty.
1323 %
1324 %  The format of the SplitImageList method is:
1325 %
1326 %      Image *SplitImageList(Image *images)
1327 %
1328 %  A description of each parameter follows:
1329 %
1330 %    o images: the image list.
1331 %
1332 */
1333 MagickExport Image *SplitImageList(Image *images)
1334 {
1335   if ((images == (Image *) NULL) || (images->next == (Image *) NULL))
1336     return((Image *) NULL);
1337   images=images->next;
1338   images->previous->next=(Image *) NULL;
1339   images->previous=(Image *) NULL;
1340   return(images);
1341 }
1342 \f
1343 /*
1344 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1345 %                                                                             %
1346 %                                                                             %
1347 %                                                                             %
1348 +   S y n c I m a g e L i s t                                                 %
1349 %                                                                             %
1350 %                                                                             %
1351 %                                                                             %
1352 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1353 %
1354 %  SyncImageList() synchronizes the scene numbers in an image list.
1355 %
1356 %  The format of the SyncImageList method is:
1357 %
1358 %      void SyncImageList(Image *images)
1359 %
1360 %  A description of each parameter follows:
1361 %
1362 %    o images: the image list.
1363 %
1364 */
1365 MagickExport void SyncImageList(Image *images)
1366 {
1367   register Image
1368     *p,
1369     *q;
1370
1371   if (images == (Image *) NULL)
1372     return;
1373   assert(images->signature == MagickSignature);
1374   for (p=images; p != (Image *) NULL; p=p->next)
1375   {
1376     for (q=p->next; q != (Image *) NULL; q=q->next)
1377       if (p->scene == q->scene)
1378         break;
1379     if (q != (Image *) NULL)
1380       break;
1381   }
1382   if (p == (Image *) NULL)
1383     return;
1384   for (p=images->next; p != (Image *) NULL; p=p->next)
1385     p->scene=p->previous->scene+1;
1386 }
1387 \f
1388 /*
1389 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1390 %                                                                             %
1391 %                                                                             %
1392 %                                                                             %
1393 +   S y n c N e x t I m a g e I n L i s t                                     %
1394 %                                                                             %
1395 %                                                                             %
1396 %                                                                             %
1397 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1398 %
1399 %  SyncNextImageInList() returns the next image in the list after the blob
1400 %  referenced is synchronized with the current image.
1401 %
1402 %  The format of the SyncNextImageInList method is:
1403 %
1404 %      Image *SyncNextImageInList(const Image *images)
1405 %
1406 %  A description of each parameter follows:
1407 %
1408 %    o images: the image list.
1409 %
1410 */
1411 MagickExport Image *SyncNextImageInList(const Image *images)
1412 {
1413   if (images == (Image *) NULL)
1414     return((Image *) NULL);
1415   assert(images->signature == MagickSignature);
1416   if (images->next == (Image *) NULL)
1417     return((Image *) NULL);
1418   if (images->blob != images->next->blob)
1419     {
1420       DestroyBlob(images->next);
1421       images->next->blob=ReferenceBlob(images->blob);
1422     }
1423   images->next->compression=images->compression;
1424   images->next->endian=images->endian;
1425   return(images->next);
1426 }