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

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                            RRRR    GGGG  BBBB                               %
   7 %                            R   R  G      B   B                              %
   8 %                            RRRR   G  GG  BBBB                               %
   9 %                            R R    G   G  B   B                              %
  10 %                            R  R    GGG   BBBB                               %
  11 %                                                                             %
  12 %                                                                             %
  13 %                     Read/Write Raw RGB Image Format                         %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                John Cristy                                  %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2008 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "MagickCore/studio.h"
  43 #include "MagickCore/blob.h"
  44 #include "MagickCore/blob-private.h"
  45 #include "MagickCore/cache.h"
  46 #include "MagickCore/colorspace.h"
  47 #include "MagickCore/colorspace-private.h"
  48 #include "MagickCore/constitute.h"
  49 #include "MagickCore/exception.h"
  50 #include "MagickCore/exception-private.h"
  51 #include "MagickCore/image.h"
  52 #include "MagickCore/image-private.h"
  53 #include "MagickCore/list.h"
  54 #include "MagickCore/magick.h"
  55 #include "MagickCore/memory_.h"
  56 #include "MagickCore/monitor.h"
  57 #include "MagickCore/monitor-private.h"
  58 #include "MagickCore/pixel-accessor.h"
  59 #include "MagickCore/quantum-private.h"
  60 #include "MagickCore/static.h"
  61 #include "MagickCore/statistic.h"
  62 #include "MagickCore/string_.h"
  63 #include "MagickCore/module.h"
  64 #include "MagickCore/utility.h"
  65 \f
  66 /*
  67   Forward declarations.
  68 */
  69 static MagickBooleanType
  70   WriteRGBImage(const ImageInfo *,Image *,ExceptionInfo *);
  71 \f
  72 /*
  73 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  74 %                                                                             %
  75 %                                                                             %
  76 %                                                                             %
  77 %   R e a d R G B I m a g e                                                   %
  78 %                                                                             %
  79 %                                                                             %
  80 %                                                                             %
  81 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  82 %
  83 %  ReadRGBImage() reads an image of raw RGB, RGBA, or RGBO samples and returns
  84 %  it.  It allocates the memory necessary for the new Image structure and
  85 %  returns a pointer to the new image.
  86 %
  87 %  The format of the ReadRGBImage method is:
  88 %
  89 %      Image *ReadRGBImage(const ImageInfo *image_info,
  90 %        ExceptionInfo *exception)
  91 %
  92 %  A description of each parameter follows:
  93 %
  94 %    o image_info: the image info.
  95 %
  96 %    o exception: return any errors or warnings in this structure.
  97 %
  98 */
  99 static Image *ReadRGBImage(const ImageInfo *image_info,
 100   ExceptionInfo *exception)
 101 {
 102   Image
 103     *canvas_image,
 104     *image;
 105
 106   MagickBooleanType
 107     status;
 108
 109   MagickOffsetType
 110     scene;
 111
 112   QuantumInfo
 113     *quantum_info;
 114
 115   QuantumType
 116     quantum_type;
 117
 118   register ssize_t
 119     i;
 120
 121   size_t
 122     length;
 123
 124   ssize_t
 125     count,
 126     y;
 127
 128   unsigned char
 129     *pixels;
 130
 131   /*
 132     Open image file.
 133   */
 134   assert(image_info != (const ImageInfo *) NULL);
 135   assert(image_info->signature == MagickSignature);
 136   if (image_info->debug != MagickFalse)
 137     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 138       image_info->filename);
 139   assert(exception != (ExceptionInfo *) NULL);
 140   assert(exception->signature == MagickSignature);
 141   image=AcquireImage(image_info,exception);
 142   if ((image->columns == 0) || (image->rows == 0))
 143     ThrowReaderException(OptionError,"MustSpecifyImageSize");
 144   image->colorspace=RGBColorspace;
 145   if (image_info->interlace != PartitionInterlace)
 146     {
 147       status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 148       if (status == MagickFalse)
 149         {
 150           image=DestroyImageList(image);
 151           return((Image *) NULL);
 152         }
 153       if (DiscardBlobBytes(image,image->offset) == MagickFalse)
 154         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 155           image->filename);
 156     }
 157   /*
 158     Create virtual canvas to support cropping (i.e. image.rgb[100x100+10+20]).
 159   */
 160   canvas_image=CloneImage(image,image->extract_info.width,1,MagickFalse,
 161     exception);
 162   (void) SetImageVirtualPixelMethod(canvas_image,BlackVirtualPixelMethod);
 163   quantum_info=AcquireQuantumInfo(image_info,canvas_image);
 164   if (quantum_info == (QuantumInfo *) NULL)
 165     ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
 166   pixels=GetQuantumPixels(quantum_info);
 167   quantum_type=RGBQuantum;
 168   if (LocaleCompare(image_info->magick,"RGBA") == 0)
 169     {
 170       quantum_type=RGBAQuantum;
 171       image->matte=MagickTrue;
 172     }
 173   if (LocaleCompare(image_info->magick,"RGBO") == 0)
 174     {
 175       quantum_type=RGBOQuantum;
 176       image->matte=MagickTrue;
 177     }
 178   if (image_info->number_scenes != 0)
 179     while (image->scene < image_info->scene)
 180     {
 181       /*
 182         Skip to next image.
 183       */
 184       image->scene++;
 185       length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
 186       for (y=0; y < (ssize_t) image->rows; y++)
 187       {
 188         count=ReadBlob(image,length,pixels);
 189         if (count != (ssize_t) length)
 190           break;
 191       }
 192     }
 193   count=0;
 194   length=0;
 195   scene=0;
 196   do
 197   {
 198     /*
 199       Read pixels to virtual canvas image then push to image.
 200     */
 201     if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
 202       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 203         break;
 204     image->colorspace=RGBColorspace;
 205     switch (image_info->interlace)
 206     {
 207       case NoInterlace:
 208       default:
 209       {
 210         /*
 211           No interlacing:  RGBRGBRGBRGBRGBRGB...
 212         */
 213         if (scene == 0)
 214           {
 215             length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);
 216             count=ReadBlob(image,length,pixels);
 217           }
 218         for (y=0; y < (ssize_t) image->extract_info.height; y++)
 219         {
 220           register const Quantum
 221             *restrict p;
 222
 223           register Quantum
 224             *restrict q;
 225
 226           register ssize_t
 227             x;
 228
 229           if (count != (ssize_t) length)
 230             {
 231               ThrowFileException(exception,CorruptImageError,
 232                 "UnexpectedEndOfFile",image->filename);
 233               break;
 234             }
 235           q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 236             exception);
 237           if (q == (Quantum *) NULL)
 238             break;
 239           length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 240             quantum_info,quantum_type,pixels,exception);
 241           if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 242             break;
 243           if (((y-image->extract_info.y) >= 0) &&
 244               ((y-image->extract_info.y) < (ssize_t) image->rows))
 245             {
 246               p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
 247                 canvas_image->columns,1,exception);
 248               q=QueueAuthenticPixels(image,0,y-image->extract_info.y,
 249                 image->columns,1,exception);
 250               if ((p == (const Quantum *) NULL) ||
 251                   (q == (Quantum *) NULL))
 252                 break;
 253               for (x=0; x < (ssize_t) image->columns; x++)
 254               {
 255                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
 256                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
 257                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
 258                 SetPixelAlpha(image,OpaqueAlpha,q);
 259                 if (image->matte != MagickFalse)
 260                   SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
 261                 p+=GetPixelChannels(canvas_image);
 262                 q+=GetPixelChannels(image);
 263               }
 264               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 265                 break;
 266             }
 267           if (image->previous == (Image *) NULL)
 268             {
 269               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 270                 image->rows);
 271               if (status == MagickFalse)
 272                 break;
 273             }
 274           count=ReadBlob(image,length,pixels);
 275         }
 276         break;
 277       }
 278       case LineInterlace:
 279       {
 280         static QuantumType
 281           quantum_types[4] =
 282           {
 283             RedQuantum,
 284             GreenQuantum,
 285             BlueQuantum,
 286             AlphaQuantum
 287           };
 288
 289         /*
 290           Line interlacing:  RRR...GGG...BBB...RRR...GGG...BBB...
 291         */
 292         if (LocaleCompare(image_info->magick,"RGBO") == 0)
 293           quantum_types[3]=OpacityQuantum;
 294         if (scene == 0)
 295           {
 296             length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
 297             count=ReadBlob(image,length,pixels);
 298           }
 299         for (y=0; y < (ssize_t) image->extract_info.height; y++)
 300         {
 301           register const Quantum
 302             *restrict p;
 303
 304           register Quantum
 305             *restrict q;
 306
 307           register ssize_t
 308             x;
 309
 310           if (count != (ssize_t) length)
 311             {
 312               ThrowFileException(exception,CorruptImageError,
 313                 "UnexpectedEndOfFile",image->filename);
 314               break;
 315             }
 316           for (i=0; i < (ssize_t) (image->matte != MagickFalse ? 4 : 3); i++)
 317           {
 318             quantum_type=quantum_types[i];
 319             q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 320               exception);
 321             if (q == (Quantum *) NULL)
 322               break;
 323             length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 324               quantum_info,quantum_type,pixels,exception);
 325             if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 326               break;
 327             if (((y-image->extract_info.y) >= 0) &&
 328                 ((y-image->extract_info.y) < (ssize_t) image->rows))
 329               {
 330                 p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
 331                   0,canvas_image->columns,1,exception);
 332                 q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 333                   image->columns,1,exception);
 334                 if ((p == (const Quantum *) NULL) ||
 335                     (q == (Quantum *) NULL))
 336                   break;
 337                 for (x=0; x < (ssize_t) image->columns; x++)
 338                 {
 339                   switch (quantum_type)
 340                   {
 341                     case RedQuantum:
 342                     {
 343                       SetPixelRed(image,GetPixelRed(canvas_image,p),q);
 344                       break;
 345                     }
 346                     case GreenQuantum:
 347                     {
 348                       SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
 349                       break;
 350                     }
 351                     case BlueQuantum:
 352                     {
 353                       SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
 354                       break;
 355                     }
 356                     case OpacityQuantum:
 357                     {
 358                       SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
 359                       break;
 360                     }
 361                     case AlphaQuantum:
 362                     {
 363                       SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
 364                       break;
 365                     }
 366                     default:
 367                       break;
 368                   }
 369                   p+=GetPixelChannels(canvas_image);
 370                   q+=GetPixelChannels(image);
 371                 }
 372                 if (SyncAuthenticPixels(image,exception) == MagickFalse)
 373                   break;
 374               }
 375             count=ReadBlob(image,length,pixels);
 376           }
 377           if (image->previous == (Image *) NULL)
 378             {
 379               status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 380                 image->rows);
 381               if (status == MagickFalse)
 382                 break;
 383             }
 384         }
 385         break;
 386       }
 387       case PlaneInterlace:
 388       {
 389         /*
 390           Plane interlacing:  RRRRRR...GGGGGG...BBBBBB...
 391         */
 392         if (scene == 0)
 393           {
 394             length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
 395             count=ReadBlob(image,length,pixels);
 396           }
 397         for (y=0; y < (ssize_t) image->extract_info.height; y++)
 398         {
 399           register const Quantum
 400             *restrict p;
 401
 402           register Quantum
 403             *restrict q;
 404
 405           register ssize_t
 406             x;
 407
 408           if (count != (ssize_t) length)
 409             {
 410               ThrowFileException(exception,CorruptImageError,
 411                 "UnexpectedEndOfFile",image->filename);
 412               break;
 413             }
 414           q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 415             exception);
 416           if (q == (Quantum *) NULL)
 417             break;
 418           length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 419             quantum_info,RedQuantum,pixels,exception);
 420           if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 421             break;
 422           if (((y-image->extract_info.y) >= 0) &&
 423               ((y-image->extract_info.y) < (ssize_t) image->rows))
 424             {
 425               p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
 426                 canvas_image->columns,1,exception);
 427               q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 428                 image->columns,1,exception);
 429               if ((p == (const Quantum *) NULL) ||
 430                   (q == (Quantum *) NULL))
 431                 break;
 432               for (x=0; x < (ssize_t) image->columns; x++)
 433               {
 434                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
 435                 p+=GetPixelChannels(canvas_image);
 436                 q+=GetPixelChannels(image);
 437               }
 438               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 439                 break;
 440             }
 441           count=ReadBlob(image,length,pixels);
 442         }
 443         if (image->previous == (Image *) NULL)
 444           {
 445             status=SetImageProgress(image,LoadImageTag,1,6);
 446             if (status == MagickFalse)
 447               break;
 448           }
 449         for (y=0; y < (ssize_t) image->extract_info.height; y++)
 450         {
 451           register const Quantum
 452             *restrict p;
 453
 454           register Quantum
 455             *restrict q;
 456
 457           register ssize_t
 458             x;
 459
 460           if (count != (ssize_t) length)
 461             {
 462               ThrowFileException(exception,CorruptImageError,
 463                 "UnexpectedEndOfFile",image->filename);
 464               break;
 465             }
 466           q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 467             exception);
 468           if (q == (Quantum *) NULL)
 469             break;
 470           length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 471             quantum_info,GreenQuantum,pixels,exception);
 472           if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 473             break;
 474           if (((y-image->extract_info.y) >= 0) &&
 475               ((y-image->extract_info.y) < (ssize_t) image->rows))
 476             {
 477               p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
 478                 canvas_image->columns,1,exception);
 479               q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 480                 image->columns,1,exception);
 481               if ((p == (const Quantum *) NULL) ||
 482                   (q == (Quantum *) NULL))
 483                 break;
 484               for (x=0; x < (ssize_t) image->columns; x++)
 485               {
 486                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
 487                 p+=GetPixelChannels(canvas_image);
 488                 q+=GetPixelChannels(image);
 489               }
 490               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 491                 break;
 492            }
 493           count=ReadBlob(image,length,pixels);
 494         }
 495         if (image->previous == (Image *) NULL)
 496           {
 497             status=SetImageProgress(image,LoadImageTag,2,6);
 498             if (status == MagickFalse)
 499               break;
 500           }
 501         for (y=0; y < (ssize_t) image->extract_info.height; y++)
 502         {
 503           register const Quantum
 504             *restrict p;
 505
 506           register Quantum
 507             *restrict q;
 508
 509           register ssize_t
 510             x;
 511
 512           if (count != (ssize_t) length)
 513             {
 514               ThrowFileException(exception,CorruptImageError,
 515                 "UnexpectedEndOfFile",image->filename);
 516               break;
 517             }
 518           q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 519             exception);
 520           if (q == (Quantum *) NULL)
 521             break;
 522           length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 523             quantum_info,BlueQuantum,pixels,exception);
 524           if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 525             break;
 526           if (((y-image->extract_info.y) >= 0) &&
 527               ((y-image->extract_info.y) < (ssize_t) image->rows))
 528             {
 529               p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
 530                 canvas_image->columns,1,exception);
 531               q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 532                 image->columns,1,exception);
 533               if ((p == (const Quantum *) NULL) ||
 534                   (q == (Quantum *) NULL))
 535                 break;
 536               for (x=0; x < (ssize_t) image->columns; x++)
 537               {
 538                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
 539                 p+=GetPixelChannels(canvas_image);
 540                 q+=GetPixelChannels(image);
 541               }
 542               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 543                 break;
 544             }
 545           count=ReadBlob(image,length,pixels);
 546         }
 547         if (image->previous == (Image *) NULL)
 548           {
 549             status=SetImageProgress(image,LoadImageTag,3,6);
 550             if (status == MagickFalse)
 551               break;
 552           }
 553         if (image->previous == (Image *) NULL)
 554           {
 555             status=SetImageProgress(image,LoadImageTag,4,6);
 556             if (status == MagickFalse)
 557               break;
 558           }
 559         if (image->matte != MagickFalse)
 560           {
 561             for (y=0; y < (ssize_t) image->extract_info.height; y++)
 562             {
 563               register const Quantum
 564                 *restrict p;
 565
 566               register Quantum
 567                 *restrict q;
 568
 569               register ssize_t
 570                 x;
 571
 572               if (count != (ssize_t) length)
 573                 {
 574                   ThrowFileException(exception,CorruptImageError,
 575                     "UnexpectedEndOfFile",image->filename);
 576                   break;
 577                 }
 578               q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 579                 exception);
 580               if (q == (Quantum *) NULL)
 581                 break;
 582               length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 583                 quantum_info,AlphaQuantum,pixels,exception);
 584               if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 585                 break;
 586               if (((y-image->extract_info.y) >= 0) &&
 587                   ((y-image->extract_info.y) < (ssize_t) image->rows))
 588                 {
 589                   p=GetVirtualPixels(canvas_image,
 590                     canvas_image->extract_info.x,0,canvas_image->columns,1,
 591                     exception);
 592                   q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 593                     image->columns,1,exception);
 594                   if ((p == (const Quantum *) NULL) ||
 595                       (q == (Quantum *) NULL))
 596                     break;
 597                   for (x=0; x < (ssize_t) image->columns; x++)
 598                   {
 599                     SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
 600                     p+=GetPixelChannels(canvas_image);
 601                     q+=GetPixelChannels(image);
 602                   }
 603                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
 604                     break;
 605                 }
 606               count=ReadBlob(image,length,pixels);
 607             }
 608             if (image->previous == (Image *) NULL)
 609               {
 610                 status=SetImageProgress(image,LoadImageTag,5,6);
 611                 if (status == MagickFalse)
 612                   break;
 613               }
 614           }
 615         if (image->previous == (Image *) NULL)
 616           {
 617             status=SetImageProgress(image,LoadImageTag,6,6);
 618             if (status == MagickFalse)
 619               break;
 620           }
 621         break;
 622       }
 623       case PartitionInterlace:
 624       {
 625         /*
 626           Partition interlacing:  RRRRRR..., GGGGGG..., BBBBBB...
 627         */
 628         AppendImageFormat("R",image->filename);
 629         status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 630         if (status == MagickFalse)
 631           {
 632             canvas_image=DestroyImageList(canvas_image);
 633             image=DestroyImageList(image);
 634             return((Image *) NULL);
 635           }
 636         if (DiscardBlobBytes(image,image->offset) == MagickFalse)
 637           ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 638             image->filename);
 639         length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);
 640         for (i=0; i < (ssize_t) scene; i++)
 641           for (y=0; y < (ssize_t) image->extract_info.height; y++)
 642             if (ReadBlob(image,length,pixels) != (ssize_t) length)
 643               {
 644                 ThrowFileException(exception,CorruptImageError,
 645                   "UnexpectedEndOfFile",image->filename);
 646                 break;
 647               }
 648         count=ReadBlob(image,length,pixels);
 649         for (y=0; y < (ssize_t) image->extract_info.height; y++)
 650         {
 651           register const Quantum
 652             *restrict p;
 653
 654           register Quantum
 655             *restrict q;
 656
 657           register ssize_t
 658             x;
 659
 660           if (count != (ssize_t) length)
 661             {
 662               ThrowFileException(exception,CorruptImageError,
 663                 "UnexpectedEndOfFile",image->filename);
 664               break;
 665             }
 666           q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 667             exception);
 668           if (q == (Quantum *) NULL)
 669             break;
 670           length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 671             quantum_info,RedQuantum,pixels,exception);
 672           if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 673             break;
 674           if (((y-image->extract_info.y) >= 0) &&
 675               ((y-image->extract_info.y) < (ssize_t) image->rows))
 676             {
 677               p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
 678                 canvas_image->columns,1,exception);
 679               q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 680                 image->columns,1,exception);
 681               if ((p == (const Quantum *) NULL) ||
 682                   (q == (Quantum *) NULL))
 683                 break;
 684               for (x=0; x < (ssize_t) image->columns; x++)
 685               {
 686                 SetPixelRed(image,GetPixelRed(canvas_image,p),q);
 687                 p+=GetPixelChannels(canvas_image);
 688                 q+=GetPixelChannels(image);
 689               }
 690               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 691                 break;
 692             }
 693           count=ReadBlob(image,length,pixels);
 694         }
 695         if (image->previous == (Image *) NULL)
 696           {
 697             status=SetImageProgress(image,LoadImageTag,1,5);
 698             if (status == MagickFalse)
 699               break;
 700           }
 701         (void) CloseBlob(image);
 702         AppendImageFormat("G",image->filename);
 703         status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 704         if (status == MagickFalse)
 705           {
 706             canvas_image=DestroyImageList(canvas_image);
 707             image=DestroyImageList(image);
 708             return((Image *) NULL);
 709           }
 710         length=GetQuantumExtent(canvas_image,quantum_info,GreenQuantum);
 711         for (i=0; i < (ssize_t) scene; i++)
 712           for (y=0; y < (ssize_t) image->extract_info.height; y++)
 713             if (ReadBlob(image,length,pixels) != (ssize_t) length)
 714               {
 715                 ThrowFileException(exception,CorruptImageError,
 716                   "UnexpectedEndOfFile",image->filename);
 717                 break;
 718               }
 719         count=ReadBlob(image,length,pixels);
 720         for (y=0; y < (ssize_t) image->extract_info.height; y++)
 721         {
 722           register const Quantum
 723             *restrict p;
 724
 725           register Quantum
 726             *restrict q;
 727
 728           register ssize_t
 729             x;
 730
 731           if (count != (ssize_t) length)
 732             {
 733               ThrowFileException(exception,CorruptImageError,
 734                 "UnexpectedEndOfFile",image->filename);
 735               break;
 736             }
 737           q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 738             exception);
 739           if (q == (Quantum *) NULL)
 740             break;
 741           length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 742             quantum_info,GreenQuantum,pixels,exception);
 743           if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 744             break;
 745           if (((y-image->extract_info.y) >= 0) &&
 746               ((y-image->extract_info.y) < (ssize_t) image->rows))
 747             {
 748               p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
 749                 canvas_image->columns,1,exception);
 750               q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 751                 image->columns,1,exception);
 752               if ((p == (const Quantum *) NULL) ||
 753                   (q == (Quantum *) NULL))
 754                 break;
 755               for (x=0; x < (ssize_t) image->columns; x++)
 756               {
 757                 SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);
 758                 p+=GetPixelChannels(canvas_image);
 759                 q+=GetPixelChannels(image);
 760               }
 761               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 762                 break;
 763            }
 764           count=ReadBlob(image,length,pixels);
 765         }
 766         if (image->previous == (Image *) NULL)
 767           {
 768             status=SetImageProgress(image,LoadImageTag,2,5);
 769             if (status == MagickFalse)
 770               break;
 771           }
 772         (void) CloseBlob(image);
 773         AppendImageFormat("B",image->filename);
 774         status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 775         if (status == MagickFalse)
 776           {
 777             canvas_image=DestroyImageList(canvas_image);
 778             image=DestroyImageList(image);
 779             return((Image *) NULL);
 780           }
 781         length=GetQuantumExtent(canvas_image,quantum_info,BlueQuantum);
 782         for (i=0; i < (ssize_t) scene; i++)
 783           for (y=0; y < (ssize_t) image->extract_info.height; y++)
 784             if (ReadBlob(image,length,pixels) != (ssize_t) length)
 785               {
 786                 ThrowFileException(exception,CorruptImageError,
 787                   "UnexpectedEndOfFile",image->filename);
 788                 break;
 789               }
 790         count=ReadBlob(image,length,pixels);
 791         for (y=0; y < (ssize_t) image->extract_info.height; y++)
 792         {
 793           register const Quantum
 794             *restrict p;
 795
 796           register Quantum
 797             *restrict q;
 798
 799           register ssize_t
 800             x;
 801
 802           if (count != (ssize_t) length)
 803             {
 804               ThrowFileException(exception,CorruptImageError,
 805                 "UnexpectedEndOfFile",image->filename);
 806               break;
 807             }
 808           q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 809             exception);
 810           if (q == (Quantum *) NULL)
 811             break;
 812           length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 813             quantum_info,BlueQuantum,pixels,exception);
 814           if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 815             break;
 816           if (((y-image->extract_info.y) >= 0) &&
 817               ((y-image->extract_info.y) < (ssize_t) image->rows))
 818             {
 819               p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,
 820                 canvas_image->columns,1,exception);
 821               q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 822                 image->columns,1,exception);
 823               if ((p == (const Quantum *) NULL) ||
 824                   (q == (Quantum *) NULL))
 825                 break;
 826               for (x=0; x < (ssize_t) image->columns; x++)
 827               {
 828                 SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);
 829                 p+=GetPixelChannels(canvas_image);
 830                 q+=GetPixelChannels(image);
 831               }
 832               if (SyncAuthenticPixels(image,exception) == MagickFalse)
 833                 break;
 834            }
 835           count=ReadBlob(image,length,pixels);
 836         }
 837         if (image->previous == (Image *) NULL)
 838           {
 839             status=SetImageProgress(image,LoadImageTag,3,5);
 840             if (status == MagickFalse)
 841               break;
 842           }
 843         if (image->matte != MagickFalse)
 844           {
 845             (void) CloseBlob(image);
 846             AppendImageFormat("A",image->filename);
 847             status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 848             if (status == MagickFalse)
 849               {
 850                 canvas_image=DestroyImageList(canvas_image);
 851                 image=DestroyImageList(image);
 852                 return((Image *) NULL);
 853               }
 854             length=GetQuantumExtent(canvas_image,quantum_info,AlphaQuantum);
 855             for (i=0; i < (ssize_t) scene; i++)
 856               for (y=0; y < (ssize_t) image->extract_info.height; y++)
 857                 if (ReadBlob(image,length,pixels) != (ssize_t) length)
 858                   {
 859                     ThrowFileException(exception,CorruptImageError,
 860                       "UnexpectedEndOfFile",image->filename);
 861                     break;
 862                   }
 863             count=ReadBlob(image,length,pixels);
 864             for (y=0; y < (ssize_t) image->extract_info.height; y++)
 865             {
 866               register const Quantum
 867                 *restrict p;
 868
 869               register Quantum
 870                 *restrict q;
 871
 872               register ssize_t
 873                 x;
 874
 875               if (count != (ssize_t) length)
 876                 {
 877                   ThrowFileException(exception,CorruptImageError,
 878                     "UnexpectedEndOfFile",image->filename);
 879                   break;
 880                 }
 881               q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,
 882                 exception);
 883               if (q == (Quantum *) NULL)
 884                 break;
 885               length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,
 886                 quantum_info,BlueQuantum,pixels,exception);
 887               if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)
 888                 break;
 889               if (((y-image->extract_info.y) >= 0) &&
 890                   ((y-image->extract_info.y) < (ssize_t) image->rows))
 891                 {
 892                   p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,
 893                     0,canvas_image->columns,1,exception);
 894                   q=GetAuthenticPixels(image,0,y-image->extract_info.y,
 895                     image->columns,1,exception);
 896                   if ((p == (const Quantum *) NULL) ||
 897                       (q == (Quantum *) NULL))
 898                     break;
 899                   for (x=0; x < (ssize_t) image->columns; x++)
 900                   {
 901                     SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);
 902                     p+=GetPixelChannels(canvas_image);
 903                     q+=GetPixelChannels(image);
 904                   }
 905                   if (SyncAuthenticPixels(image,exception) == MagickFalse)
 906                     break;
 907                }
 908               count=ReadBlob(image,length,pixels);
 909             }
 910             if (image->previous == (Image *) NULL)
 911               {
 912                 status=SetImageProgress(image,LoadImageTag,4,5);
 913                 if (status == MagickFalse)
 914                   break;
 915               }
 916           }
 917         (void) CloseBlob(image);
 918         if (image->previous == (Image *) NULL)
 919           {
 920             status=SetImageProgress(image,LoadImageTag,5,5);
 921             if (status == MagickFalse)
 922               break;
 923           }
 924         break;
 925       }
 926     }
 927     SetQuantumImageType(image,quantum_type);
 928     /*
 929       Proceed to next image.
 930     */
 931     if (image_info->number_scenes != 0)
 932       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 933         break;
 934     if (count == (ssize_t) length)
 935       {
 936         /*
 937           Allocate next image structure.
 938         */
 939         AcquireNextImage(image_info,image,exception);
 940         if (GetNextImageInList(image) == (Image *) NULL)
 941           {
 942             image=DestroyImageList(image);
 943             return((Image *) NULL);
 944           }
 945         image=SyncNextImageInList(image);
 946         status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
 947           GetBlobSize(image));
 948         if (status == MagickFalse)
 949           break;
 950       }
 951     scene++;
 952   } while (count == (ssize_t) length);
 953   quantum_info=DestroyQuantumInfo(quantum_info);
 954   canvas_image=DestroyImage(canvas_image);
 955   (void) CloseBlob(image);
 956   return(GetFirstImageInList(image));
 957 }
 958 \f
 959 /*
 960 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 961 %                                                                             %
 962 %                                                                             %
 963 %                                                                             %
 964 %   R e g i s t e r R G B I m a g e                                           %
 965 %                                                                             %
 966 %                                                                             %
 967 %                                                                             %
 968 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 969 %
 970 %  RegisterRGBImage() adds attributes for the RGB image format to
 971 %  the list of supported formats.  The attributes include the image format
 972 %  tag, a method to read and/or write the format, whether the format
 973 %  supports the saving of more than one frame to the same file or blob,
 974 %  whether the format supports native in-memory I/O, and a brief
 975 %  description of the format.
 976 %
 977 %  The format of the RegisterRGBImage method is:
 978 %
 979 %      size_t RegisterRGBImage(void)
 980 %
 981 */
 982 ModuleExport size_t RegisterRGBImage(void)
 983 {
 984   MagickInfo
 985     *entry;
 986
 987   entry=SetMagickInfo("RGB");
 988   entry->decoder=(DecodeImageHandler *) ReadRGBImage;
 989   entry->encoder=(EncodeImageHandler *) WriteRGBImage;
 990   entry->raw=MagickTrue;
 991   entry->endian_support=MagickTrue;
 992   entry->description=ConstantString("Raw red, green, and blue samples");
 993   entry->module=ConstantString("RGB");
 994   (void) RegisterMagickInfo(entry);
 995   entry=SetMagickInfo("RGBA");
 996   entry->decoder=(DecodeImageHandler *) ReadRGBImage;
 997   entry->encoder=(EncodeImageHandler *) WriteRGBImage;
 998   entry->raw=MagickTrue;
 999   entry->endian_support=MagickTrue;
1000   entry->description=ConstantString("Raw red, green, blue, and alpha samples");
1001   entry->module=ConstantString("RGB");
1002   (void) RegisterMagickInfo(entry);
1003   entry=SetMagickInfo("RGBO");
1004   entry->decoder=(DecodeImageHandler *) ReadRGBImage;
1005   entry->encoder=(EncodeImageHandler *) WriteRGBImage;
1006   entry->raw=MagickTrue;
1007   entry->endian_support=MagickTrue;
1008   entry->description=ConstantString("Raw red, green, blue, and opacity samples");
1009   entry->module=ConstantString("RGB");
1010   (void) RegisterMagickInfo(entry);
1011   return(MagickImageCoderSignature);
1012 }
1013 \f
1014 /*
1015 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1016 %                                                                             %
1017 %                                                                             %
1018 %                                                                             %
1019 %   U n r e g i s t e r R G B I m a g e                                       %
1020 %                                                                             %
1021 %                                                                             %
1022 %                                                                             %
1023 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1024 %
1025 %  UnregisterRGBImage() removes format registrations made by the RGB module
1026 %  from the list of supported formats.
1027 %
1028 %  The format of the UnregisterRGBImage method is:
1029 %
1030 %      UnregisterRGBImage(void)
1031 %
1032 */
1033 ModuleExport void UnregisterRGBImage(void)
1034 {
1035   (void) UnregisterMagickInfo("RGBO");
1036   (void) UnregisterMagickInfo("RGBA");
1037   (void) UnregisterMagickInfo("RGB");
1038 }
1039 \f
1040 /*
1041 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1042 %                                                                             %
1043 %                                                                             %
1044 %                                                                             %
1045 %   W r i t e R G B I m a g e                                                 %
1046 %                                                                             %
1047 %                                                                             %
1048 %                                                                             %
1049 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1050 %
1051 %  WriteRGBImage() writes an image to a file in the RGB, RGBA, or RGBO
1052 %  rasterfile format.
1053 %
1054 %  The format of the WriteRGBImage method is:
1055 %
1056 %      MagickBooleanType WriteRGBImage(const ImageInfo *image_info,
1057 %        Image *image,ExceptionInfo *exception)
1058 %
1059 %  A description of each parameter follows.
1060 %
1061 %    o image_info: the image info.
1062 %
1063 %    o image:  The image.
1064 %
1065 %    o exception: return any errors or warnings in this structure.
1066 %
1067 */
1068 static MagickBooleanType WriteRGBImage(const ImageInfo *image_info,
1069   Image *image,ExceptionInfo *exception)
1070 {
1071   MagickBooleanType
1072     status;
1073
1074   MagickOffsetType
1075     scene;
1076
1077   QuantumInfo
1078     *quantum_info;
1079
1080   QuantumType
1081     quantum_type;
1082
1083   size_t
1084     length;
1085
1086   ssize_t
1087     count,
1088     y;
1089
1090   unsigned char
1091     *pixels;
1092
1093   /*
1094     Allocate memory for pixels.
1095   */
1096   assert(image_info != (const ImageInfo *) NULL);
1097   assert(image_info->signature == MagickSignature);
1098   assert(image != (Image *) NULL);
1099   assert(image->signature == MagickSignature);
1100   if (image->debug != MagickFalse)
1101     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
1102   if (image_info->interlace != PartitionInterlace)
1103     {
1104       /*
1105         Open output image file.
1106       */
1107       status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
1108       if (status == MagickFalse)
1109         return(status);
1110     }
1111   quantum_type=RGBQuantum;
1112   if (LocaleCompare(image_info->magick,"RGBA") == 0)
1113     {
1114       quantum_type=RGBAQuantum;
1115       image->matte=MagickTrue;
1116     }
1117   if (LocaleCompare(image_info->magick,"RGBO") == 0)
1118     {
1119       quantum_type=RGBOQuantum;
1120       image->matte=MagickTrue;
1121     }
1122   scene=0;
1123   do
1124   {
1125     /*
1126       Convert MIFF to RGB raster pixels.
1127     */
1128     if (IsRGBColorspace(image->colorspace) == MagickFalse)
1129       (void) TransformImageColorspace(image,RGBColorspace,exception);
1130     if ((LocaleCompare(image_info->magick,"RGBA") == 0) &&
1131         (image->matte == MagickFalse))
1132       (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1133     quantum_info=AcquireQuantumInfo(image_info,image);
1134     if (quantum_info == (QuantumInfo *) NULL)
1135       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1136     pixels=GetQuantumPixels(quantum_info);
1137     switch (image_info->interlace)
1138     {
1139       case NoInterlace:
1140       default:
1141       {
1142         /*
1143           No interlacing:  RGBRGBRGBRGBRGBRGB...
1144         */
1145         for (y=0; y < (ssize_t) image->rows; y++)
1146         {
1147           register const Quantum
1148             *restrict p;
1149
1150           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1151           if (p == (const Quantum *) NULL)
1152             break;
1153           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1154             quantum_type,pixels,exception);
1155           count=WriteBlob(image,length,pixels);
1156           if (count != (ssize_t) length)
1157             break;
1158           if (image->previous == (Image *) NULL)
1159             {
1160               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1161                 image->rows);
1162               if (status == MagickFalse)
1163                 break;
1164             }
1165         }
1166         break;
1167       }
1168       case LineInterlace:
1169       {
1170         /*
1171           Line interlacing:  RRR...GGG...BBB...RRR...GGG...BBB...
1172         */
1173         for (y=0; y < (ssize_t) image->rows; y++)
1174         {
1175           register const Quantum
1176             *restrict p;
1177
1178           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1179           if (p == (const Quantum *) NULL)
1180             break;
1181           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1182             RedQuantum,pixels,exception);
1183           count=WriteBlob(image,length,pixels);
1184           if (count != (ssize_t) length)
1185             break;
1186           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1187             GreenQuantum,pixels,exception);
1188           count=WriteBlob(image,length,pixels);
1189           if (count != (ssize_t) length)
1190             break;
1191           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1192             BlueQuantum,pixels,exception);
1193           count=WriteBlob(image,length,pixels);
1194           if (count != (ssize_t) length)
1195             break;
1196           if (quantum_type == RGBAQuantum)
1197             {
1198               length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1199                 AlphaQuantum,pixels,exception);
1200               count=WriteBlob(image,length,pixels);
1201               if (count != (ssize_t) length)
1202                 break;
1203             }
1204           if (quantum_type == RGBOQuantum)
1205             {
1206               length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1207                 OpacityQuantum,pixels,exception);
1208               count=WriteBlob(image,length,pixels);
1209               if (count != (ssize_t) length)
1210                 break;
1211             }
1212           if (image->previous == (Image *) NULL)
1213             {
1214               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1215                 image->rows);
1216               if (status == MagickFalse)
1217                 break;
1218             }
1219         }
1220         break;
1221       }
1222       case PlaneInterlace:
1223       {
1224         /*
1225           Plane interlacing:  RRRRRR...GGGGGG...BBBBBB...
1226         */
1227         for (y=0; y < (ssize_t) image->rows; y++)
1228         {
1229           register const Quantum
1230             *restrict p;
1231
1232           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1233           if (p == (const Quantum *) NULL)
1234             break;
1235           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1236             RedQuantum,pixels,exception);
1237           count=WriteBlob(image,length,pixels);
1238           if (count != (ssize_t) length)
1239             break;
1240         }
1241         if (image->previous == (Image *) NULL)
1242           {
1243             status=SetImageProgress(image,SaveImageTag,1,6);
1244             if (status == MagickFalse)
1245               break;
1246           }
1247         for (y=0; y < (ssize_t) image->rows; y++)
1248         {
1249           register const Quantum
1250             *restrict p;
1251
1252           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1253           if (p == (const Quantum *) NULL)
1254             break;
1255           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1256             GreenQuantum,pixels,exception);
1257           count=WriteBlob(image,length,pixels);
1258           if (count != (ssize_t) length)
1259             break;
1260         }
1261         if (image->previous == (Image *) NULL)
1262           {
1263             status=SetImageProgress(image,SaveImageTag,2,6);
1264             if (status == MagickFalse)
1265               break;
1266           }
1267         for (y=0; y < (ssize_t) image->rows; y++)
1268         {
1269           register const Quantum
1270             *restrict p;
1271
1272           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1273           if (p == (const Quantum *) NULL)
1274             break;
1275           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1276             BlueQuantum,pixels,exception);
1277           count=WriteBlob(image,length,pixels);
1278           if (count != (ssize_t) length)
1279             break;
1280         }
1281         if (image->previous == (Image *) NULL)
1282           {
1283             status=SetImageProgress(image,SaveImageTag,3,6);
1284             if (status == MagickFalse)
1285               break;
1286           }
1287         if (quantum_type == RGBAQuantum)
1288           {
1289             for (y=0; y < (ssize_t) image->rows; y++)
1290             {
1291               register const Quantum
1292                 *restrict p;
1293
1294               p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1295               if (p == (const Quantum *) NULL)
1296                 break;
1297               length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1298                 AlphaQuantum,pixels,exception);
1299               count=WriteBlob(image,length,pixels);
1300               if (count != (ssize_t) length)
1301               break;
1302             }
1303             if (image->previous == (Image *) NULL)
1304               {
1305                 status=SetImageProgress(image,SaveImageTag,5,6);
1306                 if (status == MagickFalse)
1307                   break;
1308               }
1309           }
1310         if (image_info->interlace == PartitionInterlace)
1311           (void) CopyMagickString(image->filename,image_info->filename,
1312             MaxTextExtent);
1313         if (image->previous == (Image *) NULL)
1314           {
1315             status=SetImageProgress(image,SaveImageTag,6,6);
1316             if (status == MagickFalse)
1317               break;
1318           }
1319         break;
1320       }
1321       case PartitionInterlace:
1322       {
1323         /*
1324           Partition interlacing:  RRRRRR..., GGGGGG..., BBBBBB...
1325         */
1326         AppendImageFormat("R",image->filename);
1327         status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1328           AppendBinaryBlobMode,exception);
1329         if (status == MagickFalse)
1330           return(status);
1331         for (y=0; y < (ssize_t) image->rows; y++)
1332         {
1333           register const Quantum
1334             *restrict p;
1335
1336           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1337           if (p == (const Quantum *) NULL)
1338             break;
1339           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1340             RedQuantum,pixels,exception);
1341           count=WriteBlob(image,length,pixels);
1342           if (count != (ssize_t) length)
1343             break;
1344         }
1345         if (image->previous == (Image *) NULL)
1346           {
1347             status=SetImageProgress(image,SaveImageTag,1,6);
1348             if (status == MagickFalse)
1349               break;
1350           }
1351         (void) CloseBlob(image);
1352         AppendImageFormat("G",image->filename);
1353         status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1354           AppendBinaryBlobMode,exception);
1355         if (status == MagickFalse)
1356           return(status);
1357         for (y=0; y < (ssize_t) image->rows; y++)
1358         {
1359           register const Quantum
1360             *restrict p;
1361
1362           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1363           if (p == (const Quantum *) NULL)
1364             break;
1365           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1366             GreenQuantum,pixels,exception);
1367           count=WriteBlob(image,length,pixels);
1368           if (count != (ssize_t) length)
1369             break;
1370         }
1371         if (image->previous == (Image *) NULL)
1372           {
1373             status=SetImageProgress(image,SaveImageTag,2,6);
1374             if (status == MagickFalse)
1375               break;
1376           }
1377         (void) CloseBlob(image);
1378         AppendImageFormat("B",image->filename);
1379         status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1380           AppendBinaryBlobMode,exception);
1381         if (status == MagickFalse)
1382           return(status);
1383         for (y=0; y < (ssize_t) image->rows; y++)
1384         {
1385           register const Quantum
1386             *restrict p;
1387
1388           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1389           if (p == (const Quantum *) NULL)
1390             break;
1391           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1392             BlueQuantum,pixels,exception);
1393           count=WriteBlob(image,length,pixels);
1394           if (count != (ssize_t) length)
1395             break;
1396         }
1397         if (image->previous == (Image *) NULL)
1398           {
1399             status=SetImageProgress(image,SaveImageTag,3,6);
1400             if (status == MagickFalse)
1401               break;
1402           }
1403         (void) CloseBlob(image);
1404         if (quantum_type == RGBAQuantum)
1405           {
1406             (void) CloseBlob(image);
1407             AppendImageFormat("A",image->filename);
1408             status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1409               AppendBinaryBlobMode,exception);
1410             if (status == MagickFalse)
1411               return(status);
1412             for (y=0; y < (ssize_t) image->rows; y++)
1413             {
1414               register const Quantum
1415                 *restrict p;
1416
1417               p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1418               if (p == (const Quantum *) NULL)
1419                 break;
1420               length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1421                 AlphaQuantum,pixels,exception);
1422               count=WriteBlob(image,length,pixels);
1423               if (count != (ssize_t) length)
1424                 break;
1425             }
1426             if (image->previous == (Image *) NULL)
1427               {
1428                 status=SetImageProgress(image,SaveImageTag,5,6);
1429                 if (status == MagickFalse)
1430                   break;
1431               }
1432           }
1433         (void) CloseBlob(image);
1434         (void) CopyMagickString(image->filename,image_info->filename,
1435           MaxTextExtent);
1436         if (image->previous == (Image *) NULL)
1437           {
1438             status=SetImageProgress(image,SaveImageTag,6,6);
1439             if (status == MagickFalse)
1440               break;
1441           }
1442         break;
1443       }
1444     }
1445     quantum_info=DestroyQuantumInfo(quantum_info);
1446     if (GetNextImageInList(image) == (Image *) NULL)
1447       break;
1448     image=SyncNextImageInList(image);
1449     status=SetImageProgress(image,SaveImagesTag,scene++,
1450       GetImageListLength(image));
1451     if (status == MagickFalse)
1452       break;
1453   } while (image_info->adjoin != MagickFalse);
1454   (void) CloseBlob(image);
1455   return(MagickTrue);
1456 }