/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                            BBBB    GGGG  RRRR                               %

%                            B   B  G      R   R                              %

%                            BBBB   G  GG  RRRR                               %

%                            B   B  G   G  R R                                %

%                            BBBB    GGG   R  R                               %

%                                                                             %

%                                                                             %

%                     Read/Write Raw BGR Image Format                         %

%                                                                             %

%                              Software Design                                %

%                                   Cristy                                    %

%                                 July 1992                                   %

%                                                                             %

%                                                                             %

%  Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization         %

%  dedicated to making software imaging solutions freely available.           %

%                                                                             %

%  You may not use this file except in compliance with the License.  You may  %

%  obtain a copy of the License at                                            %

%                                                                             %

%    https://imagemagick.org/license/                                         %

%                                                                             %

%  Unless required by applicable law or agreed to in writing, software        %

%  distributed under the License is distributed on an "AS IS" BASIS,          %

%  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %

%  See the License for the specific language governing permissions and        %

%  limitations under the License.                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%

*/

/*

  Include declarations.

*/

#include "MagickCore/studio.h"

#include "MagickCore/blob.h"

#include "MagickCore/blob-private.h"

#include "MagickCore/cache.h"

#include "MagickCore/channel.h"

#include "MagickCore/colorspace.h"

#include "MagickCore/colorspace-private.h"

#include "MagickCore/constitute.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/image.h"

#include "MagickCore/image-private.h"

#include "MagickCore/list.h"

#include "MagickCore/magick.h"

#include "MagickCore/memory_.h"

#include "MagickCore/monitor.h"

#include "MagickCore/monitor-private.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/quantum-private.h"

#include "MagickCore/static.h"

#include "MagickCore/statistic.h"

#include "MagickCore/string_.h"

#include "MagickCore/module.h"

#include "MagickCore/utility.h"

/*

  Forward declarations.

*/

static MagickBooleanType

  WriteBGRImage(const ImageInfo *,Image *,ExceptionInfo *);

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d B G R I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  ReadBGRImage() reads an image of raw BGR, or BGRA samples and returns

%  it.  It allocates the memory necessary for the new Image structure and

%  returns a pointer to the new image.

%

%  The format of the ReadBGRImage method is:

%

%      Image *ReadBGRImage(const ImageInfo *image_info,

%        ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o image_info: the image info.

%

%    o exception: return any errors or warnings in this structure.

%

*/

static Image *ReadBGRImage(const ImageInfo *image_info,ExceptionInfo *exception)

{

  const void

    *stream;

  Image

    *canvas_image,

    *image;

  MagickBooleanType

    status = MagickTrue;

  MagickOffsetType

    scene;

  QuantumInfo

    *quantum_info;

  QuantumType

    quantum_type;

  ssize_t

    i;

  size_t

    length;

  ssize_t

    columns,

    count,

    y;

  unsigned char

    *pixels;

  /*

    Open image file.

  */

  assert(image_info != (const ImageInfo *) NULL);

  assert(image_info->signature == MagickCoreSignature);

  assert(exception != (ExceptionInfo *) NULL);

  assert(exception->signature == MagickCoreSignature);

  if (IsEventLogging() != MagickFalse)

    (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",

      image_info->filename);

  image=AcquireImage(image_info,exception);

  if ((image->columns == 0) || (image->rows == 0))

    ThrowReaderException(OptionError,"MustSpecifyImageSize");

  status=SetImageExtent(image,image->columns,image->rows,exception);

  if (status == MagickFalse)

    return(DestroyImageList(image));

  if (image_info->interlace != PartitionInterlace)

    {

      status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);

      if (status == MagickFalse)

        return(DestroyImageList(image));

      if (DiscardBlobBytes(image,(MagickSizeType) image->offset) == MagickFalse)

        ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",

          image->filename);

    }

  /*

    Create virtual canvas to support cropping (i.e. image.rgb[100x100+10+20]).

  */

  canvas_image=CloneImage(image,image->extract_info.width,1,MagickFalse,

    exception);

  if (canvas_image == (Image *) NULL)

    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");

  quantum_type=BGRQuantum;

  if (LocaleCompare(image_info->magick,"BGRA") == 0)

    {

      quantum_type=BGRAQuantum;

      canvas_image->alpha_trait=BlendPixelTrait;

    }

  if (LocaleCompare(image_info->magick,"BGRO") == 0)

    {

      quantum_type=BGROQuantum;

      canvas_image->alpha_trait=BlendPixelTrait;

    }

  (void) SetImageVirtualPixelMethod(canvas_image,BlackVirtualPixelMethod,

    exception);

  quantum_info=AcquireQuantumInfo(image_info,canvas_image);

  if (quantum_info == (QuantumInfo *) NULL)

    {

      canvas_image=DestroyImage(canvas_image);

      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");

    }

  pixels=GetQuantumPixels(quantum_info);

  if (image_info->number_scenes != 0)

    while (image->scene < image_info->scene)

    {

      /*

        Skip to next image.

      */

      image->scene++;

      length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);

      for (y=0; y < (ssize_t) image->rows; y++)

      {

        stream=ReadBlobStream(image,length,pixels,&count);

        if (count != (ssize_t) length)

          break;

      }

    }

  count=0;

  length=0;

  scene=0;

  status=MagickTrue;

  stream=NULL;

  columns=(ssize_t) MagickMin(image->columns,canvas_image->columns);

  do

  {

    /*

      Read pixels to virtual canvas image then push to image.

    */

    image->alpha_trait=canvas_image->alpha_trait;

    if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))

      if (image->scene >= (image_info->scene+image_info->number_scenes-1))

        break;

    status=SetImageExtent(image,image->columns,image->rows,exception);

    if (status == MagickFalse)

      break;

    switch (image_info->interlace)

    {

      case NoInterlace:

      default:

      {

        /*

          No interlacing:  BGRBGRBGRBGRBGRBGR...

        */

        if (scene == 0)

          {

            length=GetQuantumExtent(canvas_image,quantum_info,quantum_type);

            stream=ReadBlobStream(image,length,pixels,&count);

          }

        for (y=0; y < (ssize_t) image->extract_info.height; y++)

        {

          const Quantum

            *magick_restrict p;

          Quantum

            *magick_restrict q;

          ssize_t

            x;

          if (count != (ssize_t) length)

            {

              status=MagickFalse;

              ThrowFileException(exception,CorruptImageError,

                "UnexpectedEndOfFile",image->filename);

              break;

            }

          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

            exception);

          if (q == (Quantum *) NULL)

            break;

          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

            quantum_info,quantum_type,(unsigned char *) stream,exception);

          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

            break;

          if (((y-image->extract_info.y) >= 0) &&

              ((y-image->extract_info.y) < (ssize_t) image->rows))

            {

              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,

                canvas_image->columns,1,exception);

              q=QueueAuthenticPixels(image,0,y-image->extract_info.y,

                image->columns,1,exception);

              if ((p == (const Quantum *) NULL) ||

                  (q == (Quantum *) NULL))

                break;

              for (x=0; x < columns; x++)

              {

                SetPixelRed(image,GetPixelRed(canvas_image,p),q);

                SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);

                SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);

                SetPixelAlpha(image,OpaqueAlpha,q);

                if (image->alpha_trait != UndefinedPixelTrait)

                  SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);

                p+=(ptrdiff_t) GetPixelChannels(canvas_image);

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              if (SyncAuthenticPixels(image,exception) == MagickFalse)

                break;

            }

          if (image->previous == (Image *) NULL)

            {

              status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,

                image->rows);

              if (status == MagickFalse)

                break;

            }

          stream=ReadBlobStream(image,length,pixels,&count);

        }

        break;

      }

      case LineInterlace:

      {

        static QuantumType

          quantum_types[4] =

          {

            BlueQuantum,

            GreenQuantum,

            RedQuantum,

            AlphaQuantum

          };

        /*

          Line interlacing:  BBB...GGG...RRR...RRR...GGG...BBB...

        */

        if (scene == 0)

          {

            length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);

            stream=ReadBlobStream(image,length,pixels,&count);

          }

        for (y=0; y < (ssize_t) image->extract_info.height; y++)

        {

          for (i=0; i < (ssize_t) (image->alpha_trait != UndefinedPixelTrait ? 4 : 3); i++)

          {

            const Quantum

              *magick_restrict p;

            Quantum

              *magick_restrict q;

            ssize_t

              x;

            if (count != (ssize_t) length)

              {

                status=MagickFalse;

                ThrowFileException(exception,CorruptImageError,

                  "UnexpectedEndOfFile",image->filename);

                break;

              }

            quantum_type=quantum_types[i];

            q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

              exception);

            if (q == (Quantum *) NULL)

              break;

            length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

              quantum_info,quantum_type,(unsigned char *) stream,exception);

            if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

              break;

            if (((y-image->extract_info.y) >= 0) &&

                ((y-image->extract_info.y) < (ssize_t) image->rows))

              {

                p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,

                  canvas_image->columns,1,exception);

                q=GetAuthenticPixels(image,0,y-image->extract_info.y,

                  image->columns,1,exception);

                if ((p == (const Quantum *) NULL) ||

                    (q == (Quantum *) NULL))

                  break;

                for (x=0; x < columns; x++)

                {

                  switch (quantum_type)

                  {

                    case RedQuantum:

                    {

                      SetPixelRed(image,GetPixelRed(canvas_image,p),q);

                      break;

                    }

                    case GreenQuantum:

                    {

                      SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);

                      break;

                    }

                    case BlueQuantum:

                    {

                      SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);

                      break;

                    }

                    case OpacityQuantum:

                    {

                      SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);

                      break;

                    }

                    case AlphaQuantum:

                    {

                      SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);

                      break;

                    }

                    default:

                      break;

                  }

                  p+=(ptrdiff_t) GetPixelChannels(canvas_image);

                  q+=(ptrdiff_t) GetPixelChannels(image);

                }

                if (SyncAuthenticPixels(image,exception) == MagickFalse)

                  break;

              }

            stream=ReadBlobStream(image,length,pixels,&count);

          }

          if (image->previous == (Image *) NULL)

            {

              status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,

                image->rows);

              if (status == MagickFalse)

                break;

            }

        }

        break;

      }

      case PlaneInterlace:

      {

        /*

          Plane interlacing:  RRRRRR...GGGGGG...BBBBBB...

        */

        if (scene == 0)

          {

            length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);

            stream=ReadBlobStream(image,length,pixels,&count);

          }

        for (y=0; y < (ssize_t) image->extract_info.height; y++)

        {

          const Quantum

            *magick_restrict p;

          Quantum

            *magick_restrict q;

          ssize_t

            x;

          if (count != (ssize_t) length)

            {

              status=MagickFalse;

              ThrowFileException(exception,CorruptImageError,

                "UnexpectedEndOfFile",image->filename);

              break;

            }

          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

            exception);

          if (q == (Quantum *) NULL)

            break;

          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

            quantum_info,RedQuantum,(unsigned char *) stream,exception);

          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

            break;

          if (((y-image->extract_info.y) >= 0) &&

              ((y-image->extract_info.y) < (ssize_t) image->rows))

            {

              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,

                canvas_image->columns,1,exception);

              q=GetAuthenticPixels(image,0,y-image->extract_info.y,

                image->columns,1,exception);

              if ((p == (const Quantum *) NULL) ||

                  (q == (Quantum *) NULL))

                break;

              for (x=0; x < columns; x++)

              {

                SetPixelRed(image,GetPixelRed(canvas_image,p),q);

                p+=(ptrdiff_t) GetPixelChannels(canvas_image);

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              if (SyncAuthenticPixels(image,exception) == MagickFalse)

                break;

            }

          stream=ReadBlobStream(image,length,pixels,&count);

        }

        if (image->previous == (Image *) NULL)

          {

            status=SetImageProgress(image,LoadImageTag,1,6);

            if (status == MagickFalse)

              break;

          }

        for (y=0; y < (ssize_t) image->extract_info.height; y++)

        {

          const Quantum

            *magick_restrict p;

          Quantum

            *magick_restrict q;

          ssize_t

            x;

          if (count != (ssize_t) length)

            {

              status=MagickFalse;

              ThrowFileException(exception,CorruptImageError,

                "UnexpectedEndOfFile",image->filename);

              break;

            }

          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

            exception);

          if (q == (Quantum *) NULL)

            break;

          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

            quantum_info,GreenQuantum,(unsigned char *) stream,exception);

          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

            break;

          if (((y-image->extract_info.y) >= 0) &&

              ((y-image->extract_info.y) < (ssize_t) image->rows))

            {

              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,

                canvas_image->columns,1,exception);

              q=GetAuthenticPixels(image,0,y-image->extract_info.y,

                image->columns,1,exception);

              if ((p == (const Quantum *) NULL) ||

                  (q == (Quantum *) NULL))

                break;

              for (x=0; x < columns; x++)

              {

                SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);

                p+=(ptrdiff_t) GetPixelChannels(canvas_image);

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              if (SyncAuthenticPixels(image,exception) == MagickFalse)

                break;

           }

          stream=ReadBlobStream(image,length,pixels,&count);

        }

        if (image->previous == (Image *) NULL)

          {

            status=SetImageProgress(image,LoadImageTag,2,6);

            if (status == MagickFalse)

              break;

          }

        for (y=0; y < (ssize_t) image->extract_info.height; y++)

        {

          const Quantum

            *magick_restrict p;

          Quantum

            *magick_restrict q;

          ssize_t

            x;

          if (count != (ssize_t) length)

            {

              status=MagickFalse;

              ThrowFileException(exception,CorruptImageError,

                "UnexpectedEndOfFile",image->filename);

              break;

            }

          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

            exception);

          if (q == (Quantum *) NULL)

            break;

          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

            quantum_info,BlueQuantum,(unsigned char *) stream,exception);

          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

            break;

          if (((y-image->extract_info.y) >= 0) &&

              ((y-image->extract_info.y) < (ssize_t) image->rows))

            {

              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,

                canvas_image->columns,1,exception);

              q=GetAuthenticPixels(image,0,y-image->extract_info.y,

                image->columns,1,exception);

              if ((p == (const Quantum *) NULL) ||

                  (q == (Quantum *) NULL))

                break;

              for (x=0; x < columns; x++)

              {

                SetPixelBlue(image,GetPixelBlue(canvas_image,p),q);

                p+=(ptrdiff_t) GetPixelChannels(canvas_image);

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              if (SyncAuthenticPixels(image,exception) == MagickFalse)

                break;

            }

          stream=ReadBlobStream(image,length,pixels,&count);

        }

        if (image->previous == (Image *) NULL)

          {

            status=SetImageProgress(image,LoadImageTag,3,6);

            if (status == MagickFalse)

              break;

          }

        if (image->previous == (Image *) NULL)

          {

            status=SetImageProgress(image,LoadImageTag,4,6);

            if (status == MagickFalse)

              break;

          }

        if (image->alpha_trait != UndefinedPixelTrait)

          {

            for (y=0; y < (ssize_t) image->extract_info.height; y++)

            {

              const Quantum

                *magick_restrict p;

              Quantum

                *magick_restrict q;

              ssize_t

                x;

              if (count != (ssize_t) length)

                {

                  status=MagickFalse;

                  ThrowFileException(exception,CorruptImageError,

                    "UnexpectedEndOfFile",image->filename);

                  break;

                }

              q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

                exception);

              if (q == (Quantum *) NULL)

                break;

              length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

                quantum_info,AlphaQuantum,(unsigned char *) stream,exception);

              if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

                break;

              if (((y-image->extract_info.y) >= 0) &&

                  ((y-image->extract_info.y) < (ssize_t) image->rows))

                {

                  p=GetVirtualPixels(canvas_image,

                    canvas_image->extract_info.x,0,canvas_image->columns,1,

                    exception);

                  q=GetAuthenticPixels(image,0,y-image->extract_info.y,

                    image->columns,1,exception);

                  if ((p == (const Quantum *) NULL) ||

                      (q == (Quantum *) NULL))

                    break;

                  for (x=0; x < columns; x++)

                  {

                    SetPixelAlpha(image,GetPixelAlpha(canvas_image,p),q);

                    p+=(ptrdiff_t) GetPixelChannels(canvas_image);

                    q+=(ptrdiff_t) GetPixelChannels(image);

                  }

                  if (SyncAuthenticPixels(image,exception) == MagickFalse)

                    break;

                }

              stream=ReadBlobStream(image,length,pixels,&count);

            }

            if (image->previous == (Image *) NULL)

              {

                status=SetImageProgress(image,LoadImageTag,5,6);

                if (status == MagickFalse)

                  break;

              }

          }

        if (image->previous == (Image *) NULL)

          {

            status=SetImageProgress(image,LoadImageTag,6,6);

            if (status == MagickFalse)

              break;

          }

        break;

      }

      case PartitionInterlace:

      {

        /*

          Partition interlacing:  BBBBBB..., GGGGGG..., RRRRRR...

        */

        AppendImageFormat("B",image->filename);

        status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);

        if (status == MagickFalse)

          break;

        if (DiscardBlobBytes(image,(MagickSizeType) image->offset) == MagickFalse)

          {

            status=MagickFalse;

            ThrowFileException(exception,CorruptImageError,

              "UnexpectedEndOfFile",image->filename);

            break;

          }

        length=GetQuantumExtent(canvas_image,quantum_info,BlueQuantum);

        for (i=0; i < (ssize_t) scene; i++)

        {

          for (y=0; y < (ssize_t) image->extract_info.height; y++)

          {

            stream=ReadBlobStream(image,length,pixels,&count);

            if (count != (ssize_t) length)

              break;

          }

          if (count != (ssize_t) length)

            break;

        }

        stream=ReadBlobStream(image,length,pixels,&count);

        for (y=0; y < (ssize_t) image->extract_info.height; y++)

        {

          const Quantum

            *magick_restrict p;

          Quantum

            *magick_restrict q;

          ssize_t

            x;

          if (count != (ssize_t) length)

            {

              status=MagickFalse;

              ThrowFileException(exception,CorruptImageError,

                "UnexpectedEndOfFile",image->filename);

              break;

            }

          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

            exception);

          if (q == (Quantum *) NULL)

            break;

          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

            quantum_info,BlueQuantum,(unsigned char *) stream,exception);

          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

            break;

          if (((y-image->extract_info.y) >= 0) &&

              ((y-image->extract_info.y) < (ssize_t) image->rows))

            {

              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,

                canvas_image->columns,1,exception);

              q=GetAuthenticPixels(image,0,y-image->extract_info.y,

                image->columns,1,exception);

              if ((p == (const Quantum *) NULL) ||

                  (q == (Quantum *) NULL))

                break;

              for (x=0; x < columns; x++)

              {

                SetPixelRed(image,GetPixelRed(canvas_image,p),q);

                p+=(ptrdiff_t) GetPixelChannels(canvas_image);

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              if (SyncAuthenticPixels(image,exception) == MagickFalse)

                break;

            }

          stream=ReadBlobStream(image,length,pixels,&count);

        }

        if (image->previous == (Image *) NULL)

          {

            status=SetImageProgress(image,LoadImageTag,1,5);

            if (status == MagickFalse)

              break;

          }

        if (CloseBlob(image) == MagickFalse)

          break;

        AppendImageFormat("G",image->filename);

        status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);

        if (status == MagickFalse)

          break;

        length=GetQuantumExtent(canvas_image,quantum_info,GreenQuantum);

        for (i=0; i < (ssize_t) scene; i++)

        {

          for (y=0; y < (ssize_t) image->extract_info.height; y++)

          {

            stream=ReadBlobStream(image,length,pixels,&count);

            if (count != (ssize_t) length)

              break;

          }

          if (count != (ssize_t) length)

            break;

        }

        stream=ReadBlobStream(image,length,pixels,&count);

        for (y=0; y < (ssize_t) image->extract_info.height; y++)

        {

          const Quantum

            *magick_restrict p;

          Quantum

            *magick_restrict q;

          ssize_t

            x;

          if (count != (ssize_t) length)

            {

              status=MagickFalse;

              ThrowFileException(exception,CorruptImageError,

                "UnexpectedEndOfFile",image->filename);

              break;

            }

          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

            exception);

          if (q == (Quantum *) NULL)

            break;

          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

            quantum_info,GreenQuantum,(unsigned char *) stream,exception);

          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

            break;

          if (((y-image->extract_info.y) >= 0) &&

              ((y-image->extract_info.y) < (ssize_t) image->rows))

            {

              p=GetVirtualPixels(canvas_image,canvas_image->extract_info.x,0,

                canvas_image->columns,1,exception);

              q=GetAuthenticPixels(image,0,y-image->extract_info.y,

                image->columns,1,exception);

              if ((p == (const Quantum *) NULL) ||

                  (q == (Quantum *) NULL))

                break;

              for (x=0; x < columns; x++)

              {

                SetPixelGreen(image,GetPixelGreen(canvas_image,p),q);

                p+=(ptrdiff_t) GetPixelChannels(canvas_image);

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              if (SyncAuthenticPixels(image,exception) == MagickFalse)

                break;

           }

          stream=ReadBlobStream(image,length,pixels,&count);

        }

        if (image->previous == (Image *) NULL)

          {

            status=SetImageProgress(image,LoadImageTag,2,5);

            if (status == MagickFalse)

              break;

          }

        if (CloseBlob(image) == MagickFalse)

          break;

        AppendImageFormat("R",image->filename);

        status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);

        if (status == MagickFalse)

          break;

        length=GetQuantumExtent(canvas_image,quantum_info,RedQuantum);

        for (i=0; i < (ssize_t) scene; i++)

        {

          for (y=0; y < (ssize_t) image->extract_info.height; y++)

          {

            stream=ReadBlobStream(image,length,pixels,&count);

            if (count != (ssize_t) length)

              break;

          }

          if (count != (ssize_t) length)

            break;

        }

        stream=ReadBlobStream(image,length,pixels,&count);

        for (y=0; y < (ssize_t) image->extract_info.height; y++)

        {

          const Quantum

            *magick_restrict p;

          Quantum

            *magick_restrict q;

          ssize_t

            x;

          if (count != (ssize_t) length)

            {

              status=MagickFalse;

              ThrowFileException(exception,CorruptImageError,

                "UnexpectedEndOfFile",image->filename);

              break;

            }

          q=GetAuthenticPixels(canvas_image,0,0,canvas_image->columns,1,

            exception);

          if (q == (Quantum *) NULL)

            break;

          length=ImportQuantumPixels(canvas_image,(CacheView *) NULL,

            quantum_info,RedQuantum,(unsigned char *) stream,exception);

          if (SyncAuthenticPixels(canvas_image,exception) == MagickFalse)

            break;

          if (((y-image->extract_info.y) >= 0) &&

              ((y-image->extract_info.y) < (ssize_t) image->rows))

            {