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       if (image->matte == MagickFalse)
1116         SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1117     }
1118   if (LocaleCompare(image_info->magick,"RGBO") == 0)
1119     {
1120       quantum_type=RGBOQuantum;
1121       if (image->matte == MagickFalse)
1122         SetImageAlphaChannel(image,QuantumRange-OpaqueAlphaChannel,exception);
1123     }
1124   scene=0;
1125   do
1126   {
1127     /*
1128       Convert MIFF to RGB raster pixels.
1129     */
1130     if (IsRGBColorspace(image->colorspace) == MagickFalse)
1131       (void) TransformImageColorspace(image,RGBColorspace,exception);
1132     if ((LocaleCompare(image_info->magick,"RGBA") == 0) &&
1133         (image->matte == MagickFalse))
1134       (void) SetImageAlphaChannel(image,OpaqueAlphaChannel,exception);
1135     quantum_info=AcquireQuantumInfo(image_info,image);
1136     if (quantum_info == (QuantumInfo *) NULL)
1137       ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
1138     pixels=GetQuantumPixels(quantum_info);
1139     switch (image_info->interlace)
1140     {
1141       case NoInterlace:
1142       default:
1143       {
1144         /*
1145           No interlacing:  RGBRGBRGBRGBRGBRGB...
1146         */
1147         for (y=0; y < (ssize_t) image->rows; y++)
1148         {
1149           register const Quantum
1150             *restrict p;
1151
1152           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1153           if (p == (const Quantum *) NULL)
1154             break;
1155           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1156             quantum_type,pixels,exception);
1157           count=WriteBlob(image,length,pixels);
1158           if (count != (ssize_t) length)
1159             break;
1160           if (image->previous == (Image *) NULL)
1161             {
1162               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1163                 image->rows);
1164               if (status == MagickFalse)
1165                 break;
1166             }
1167         }
1168         break;
1169       }
1170       case LineInterlace:
1171       {
1172         /*
1173           Line interlacing:  RRR...GGG...BBB...RRR...GGG...BBB...
1174         */
1175         for (y=0; y < (ssize_t) image->rows; y++)
1176         {
1177           register const Quantum
1178             *restrict p;
1179
1180           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1181           if (p == (const Quantum *) NULL)
1182             break;
1183           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1184             RedQuantum,pixels,exception);
1185           count=WriteBlob(image,length,pixels);
1186           if (count != (ssize_t) length)
1187             break;
1188           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1189             GreenQuantum,pixels,exception);
1190           count=WriteBlob(image,length,pixels);
1191           if (count != (ssize_t) length)
1192             break;
1193           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1194             BlueQuantum,pixels,exception);
1195           count=WriteBlob(image,length,pixels);
1196           if (count != (ssize_t) length)
1197             break;
1198           if (quantum_type == RGBAQuantum)
1199             {
1200               length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1201                 AlphaQuantum,pixels,exception);
1202               count=WriteBlob(image,length,pixels);
1203               if (count != (ssize_t) length)
1204                 break;
1205             }
1206           if (quantum_type == RGBOQuantum)
1207             {
1208               length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1209                 OpacityQuantum,pixels,exception);
1210               count=WriteBlob(image,length,pixels);
1211               if (count != (ssize_t) length)
1212                 break;
1213             }
1214           if (image->previous == (Image *) NULL)
1215             {
1216               status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
1217                 image->rows);
1218               if (status == MagickFalse)
1219                 break;
1220             }
1221         }
1222         break;
1223       }
1224       case PlaneInterlace:
1225       {
1226         /*
1227           Plane interlacing:  RRRRRR...GGGGGG...BBBBBB...
1228         */
1229         for (y=0; y < (ssize_t) image->rows; y++)
1230         {
1231           register const Quantum
1232             *restrict p;
1233
1234           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1235           if (p == (const Quantum *) NULL)
1236             break;
1237           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1238             RedQuantum,pixels,exception);
1239           count=WriteBlob(image,length,pixels);
1240           if (count != (ssize_t) length)
1241             break;
1242         }
1243         if (image->previous == (Image *) NULL)
1244           {
1245             status=SetImageProgress(image,SaveImageTag,1,6);
1246             if (status == MagickFalse)
1247               break;
1248           }
1249         for (y=0; y < (ssize_t) image->rows; y++)
1250         {
1251           register const Quantum
1252             *restrict p;
1253
1254           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1255           if (p == (const Quantum *) NULL)
1256             break;
1257           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1258             GreenQuantum,pixels,exception);
1259           count=WriteBlob(image,length,pixels);
1260           if (count != (ssize_t) length)
1261             break;
1262         }
1263         if (image->previous == (Image *) NULL)
1264           {
1265             status=SetImageProgress(image,SaveImageTag,2,6);
1266             if (status == MagickFalse)
1267               break;
1268           }
1269         for (y=0; y < (ssize_t) image->rows; y++)
1270         {
1271           register const Quantum
1272             *restrict p;
1273
1274           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1275           if (p == (const Quantum *) NULL)
1276             break;
1277           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1278             BlueQuantum,pixels,exception);
1279           count=WriteBlob(image,length,pixels);
1280           if (count != (ssize_t) length)
1281             break;
1282         }
1283         if (image->previous == (Image *) NULL)
1284           {
1285             status=SetImageProgress(image,SaveImageTag,3,6);
1286             if (status == MagickFalse)
1287               break;
1288           }
1289         if (quantum_type == RGBAQuantum)
1290           {
1291             for (y=0; y < (ssize_t) image->rows; y++)
1292             {
1293               register const Quantum
1294                 *restrict p;
1295
1296               p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1297               if (p == (const Quantum *) NULL)
1298                 break;
1299               length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1300                 AlphaQuantum,pixels,exception);
1301               count=WriteBlob(image,length,pixels);
1302               if (count != (ssize_t) length)
1303               break;
1304             }
1305             if (image->previous == (Image *) NULL)
1306               {
1307                 status=SetImageProgress(image,SaveImageTag,5,6);
1308                 if (status == MagickFalse)
1309                   break;
1310               }
1311           }
1312         if (image_info->interlace == PartitionInterlace)
1313           (void) CopyMagickString(image->filename,image_info->filename,
1314             MaxTextExtent);
1315         if (image->previous == (Image *) NULL)
1316           {
1317             status=SetImageProgress(image,SaveImageTag,6,6);
1318             if (status == MagickFalse)
1319               break;
1320           }
1321         break;
1322       }
1323       case PartitionInterlace:
1324       {
1325         /*
1326           Partition interlacing:  RRRRRR..., GGGGGG..., BBBBBB...
1327         */
1328         AppendImageFormat("R",image->filename);
1329         status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1330           AppendBinaryBlobMode,exception);
1331         if (status == MagickFalse)
1332           return(status);
1333         for (y=0; y < (ssize_t) image->rows; y++)
1334         {
1335           register const Quantum
1336             *restrict p;
1337
1338           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1339           if (p == (const Quantum *) NULL)
1340             break;
1341           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1342             RedQuantum,pixels,exception);
1343           count=WriteBlob(image,length,pixels);
1344           if (count != (ssize_t) length)
1345             break;
1346         }
1347         if (image->previous == (Image *) NULL)
1348           {
1349             status=SetImageProgress(image,SaveImageTag,1,6);
1350             if (status == MagickFalse)
1351               break;
1352           }
1353         (void) CloseBlob(image);
1354         AppendImageFormat("G",image->filename);
1355         status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1356           AppendBinaryBlobMode,exception);
1357         if (status == MagickFalse)
1358           return(status);
1359         for (y=0; y < (ssize_t) image->rows; y++)
1360         {
1361           register const Quantum
1362             *restrict p;
1363
1364           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1365           if (p == (const Quantum *) NULL)
1366             break;
1367           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1368             GreenQuantum,pixels,exception);
1369           count=WriteBlob(image,length,pixels);
1370           if (count != (ssize_t) length)
1371             break;
1372         }
1373         if (image->previous == (Image *) NULL)
1374           {
1375             status=SetImageProgress(image,SaveImageTag,2,6);
1376             if (status == MagickFalse)
1377               break;
1378           }
1379         (void) CloseBlob(image);
1380         AppendImageFormat("B",image->filename);
1381         status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1382           AppendBinaryBlobMode,exception);
1383         if (status == MagickFalse)
1384           return(status);
1385         for (y=0; y < (ssize_t) image->rows; y++)
1386         {
1387           register const Quantum
1388             *restrict p;
1389
1390           p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1391           if (p == (const Quantum *) NULL)
1392             break;
1393           length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1394             BlueQuantum,pixels,exception);
1395           count=WriteBlob(image,length,pixels);
1396           if (count != (ssize_t) length)
1397             break;
1398         }
1399         if (image->previous == (Image *) NULL)
1400           {
1401             status=SetImageProgress(image,SaveImageTag,3,6);
1402             if (status == MagickFalse)
1403               break;
1404           }
1405         (void) CloseBlob(image);
1406         if (quantum_type == RGBAQuantum)
1407           {
1408             (void) CloseBlob(image);
1409             AppendImageFormat("A",image->filename);
1410             status=OpenBlob(image_info,image,scene == 0 ? WriteBinaryBlobMode :
1411               AppendBinaryBlobMode,exception);
1412             if (status == MagickFalse)
1413               return(status);
1414             for (y=0; y < (ssize_t) image->rows; y++)
1415             {
1416               register const Quantum
1417                 *restrict p;
1418
1419               p=GetVirtualPixels(image,0,y,image->columns,1,exception);
1420               if (p == (const Quantum *) NULL)
1421                 break;
1422               length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
1423                 AlphaQuantum,pixels,exception);
1424               count=WriteBlob(image,length,pixels);
1425               if (count != (ssize_t) length)
1426                 break;
1427             }
1428             if (image->previous == (Image *) NULL)
1429               {
1430                 status=SetImageProgress(image,SaveImageTag,5,6);
1431                 if (status == MagickFalse)
1432                   break;
1433               }
1434           }
1435         (void) CloseBlob(image);
1436         (void) CopyMagickString(image->filename,image_info->filename,
1437           MaxTextExtent);
1438         if (image->previous == (Image *) NULL)
1439           {
1440             status=SetImageProgress(image,SaveImageTag,6,6);
1441             if (status == MagickFalse)
1442               break;
1443           }
1444         break;
1445       }
1446     }
1447     quantum_info=DestroyQuantumInfo(quantum_info);
1448     if (GetNextImageInList(image) == (Image *) NULL)
1449       break;
1450     image=SyncNextImageInList(image);
1451     status=SetImageProgress(image,SaveImagesTag,scene++,
1452       GetImageListLength(image));
1453     if (status == MagickFalse)
1454       break;
1455   } while (image_info->adjoin != MagickFalse);
1456   (void) CloseBlob(image);
1457   return(MagickTrue);
1458 }