/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%                            PPPP   N   N  M   M                              %

%                            P   P  NN  N  MM MM                              %

%                            PPPP   N N N  M M M                              %

%                            P      N  NN  M   M                              %

%                            P      N   N  M   M                              %

%                                                                             %

%                                                                             %

%               Read/Write PBMPlus Portable Anymap 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/script/license.php                               %

%                                                                             %

%  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/attribute.h"

#include "MagickCore/blob.h"

#include "MagickCore/blob-private.h"

#include "MagickCore/cache.h"

#include "MagickCore/color.h"

#include "MagickCore/color-private.h"

#include "MagickCore/colorspace.h"

#include "MagickCore/colorspace-private.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/module.h"

#include "MagickCore/monitor.h"

#include "MagickCore/monitor-private.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/property.h"

#include "MagickCore/quantum-private.h"

#include "MagickCore/static.h"

#include "MagickCore/statistic.h"

#include "MagickCore/string_.h"

#include "MagickCore/string-private.h"

#include "coders/coders-private.h"

/*

  Typedef declarations.

*/

typedef struct _CommentInfo

{

  char

    *comment;

  size_t

    extent;

} CommentInfo;

/*

  Forward declarations.

*/

static MagickBooleanType

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

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   I s P N M                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  IsPNM() returns MagickTrue if the image format type, identified by the

%  magick string, is PNM.

%

%  The format of the IsPNM method is:

%

%      MagickBooleanType IsPNM(const unsigned char *magick,const size_t extent)

%

%  A description of each parameter follows:

%

%    o magick: compare image format pattern against these bytes.

%

%    o extent: Specifies the extent of the magick string.

%

*/

static MagickBooleanType IsPNM(const unsigned char *magick,const size_t extent)

{

  if (extent < 2)

    return(MagickFalse);

  if ((*magick == (unsigned char) 'P') &&

      ((magick[1] == '1') || (magick[1] == '2') || (magick[1] == '3') ||

       (magick[1] == '4') || (magick[1] == '5') || (magick[1] == '6') ||

       (magick[1] == '7') || (magick[1] == 'F') || (magick[1] == 'f') ||

       (magick[1] == 'H') || (magick[1] == 'h')))

    return(MagickTrue);

  return(MagickFalse);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d P N M I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  ReadPNMImage() reads a Portable Anymap image file 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 ReadPNMImage method is:

%

%      Image *ReadPNMImage(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 int PNMComment(Image *image,CommentInfo *comment_info,

  ExceptionInfo *exception)

{

  int

    c;

  char

    *p;

  /*

    Read comment.

  */

  (void) exception;

  p=comment_info->comment+strlen(comment_info->comment);

  for (c='#'; (c != EOF) && (c != (int) '\n') && (c != (int) '\r'); p++)

  {

    if ((size_t) (p-comment_info->comment+1) >= comment_info->extent)

      {

        comment_info->extent<<=1;

        comment_info->comment=(char *) ResizeQuantumMemory(

          comment_info->comment,comment_info->extent,

          sizeof(*comment_info->comment));

        if (comment_info->comment == (char *) NULL)

          return(-1);

        p=comment_info->comment+strlen(comment_info->comment);

      }

    c=ReadBlobByte(image);

    if (c != EOF)

      {

        *p=(char) c;

        *(p+1)='\0';

      }

  }

  return(c);

}

static unsigned int PNMInteger(Image *image,CommentInfo *comment_info,

  const unsigned int base,ExceptionInfo *exception)

{

  int

    c;

  unsigned int

    value;

  /*

    Skip any leading whitespace.

  */

  do

  {

    c=ReadBlobByte(image);

    if (c == EOF)

      return(0);

    if (c == (int) '#')

      c=PNMComment(image,comment_info,exception);

  } while ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r'));

  if (base == 2)

    return((unsigned int) (c-(int) '0'));

  /*

    Evaluate number.

  */

  value=0;

  while (isdigit((int) ((unsigned char) c)) != 0)

  {

    if (value <= (unsigned int) (INT_MAX/10))

      {

        value*=10;

        if (value <= (unsigned int) (INT_MAX-(c-(int) '0')))

          value+=(unsigned int) (c-(int) '0');

      }

    c=ReadBlobByte(image);

    if (c == EOF)

      return(0);

  }

  if (c == (int) '#')

    c=PNMComment(image,comment_info,exception);

  return(value);

}

static char *PNMString(Image *image,char *string,const size_t extent)

{

  int

    c;

  size_t

    i;

  for (i=0; i < (extent-1L); i++)

  {

    c=ReadBlobByte(image);

    if (c == EOF)

      {

        if (i == 0)

          return((char *) NULL);

        break;

      }

    string[i]=(char) c;

    if (c == '\n' || c == '\r')

      break;

  }

  string[i]='\0';

  return(string);

}

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

{

#define ThrowPNMException(exception,message) \

{ \

  if (comment_info.comment != (char *) NULL)  \

    comment_info.comment=DestroyString(comment_info.comment); \

  if (quantum_info != (QuantumInfo *) NULL) \

    quantum_info=DestroyQuantumInfo(quantum_info); \

  ThrowReaderException((exception),(message)); \

}

  char

    format;

  ColorspaceType

    colorspace;

  CommentInfo

    comment_info;

  const void

    *stream;

  double

    quantum_scale;

  Image

    *image;

  MagickBooleanType

    is_gray = MagickTrue,

    is_mono = MagickTrue,

    status;

  QuantumAny

    max_value;

  QuantumInfo

    *quantum_info;

  QuantumType

    quantum_type;

  size_t

    depth,

    extent;

  ssize_t

    count,

    row,

    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);

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

  if (status == MagickFalse)

    {

      image=DestroyImageList(image);

      return((Image *) NULL);

    }

  /*

    Read PNM image.

  */

  comment_info.comment=(char *) NULL;

  quantum_info=(QuantumInfo *) NULL;

  count=ReadBlob(image,1,(unsigned char *) &format);

  do

  {

    /*

      Initialize image structure.

    */

    comment_info.comment=AcquireString(NULL);

    comment_info.extent=MagickPathExtent;

    if ((count != 1) || (format != 'P'))

      ThrowPNMException(CorruptImageError,"ImproperImageHeader");

    max_value=1;

    colorspace=UndefinedColorspace;

    quantum_type=UndefinedQuantum;

    quantum_scale=1.0;

    format=(char) ReadBlobByte(image);

    if (format != '7')

      {

        /*

          PBM, PGM, PPM, and PNM.

        */

        if (ReadBlobByte(image) == '4')

          image->alpha_trait=BlendPixelTrait;

        image->columns=(size_t) PNMInteger(image,&comment_info,10,exception);

        image->rows=(size_t) PNMInteger(image,&comment_info,10,exception);

        if ((format == 'f') || (format == 'F') || (format == 'h') ||

            (format == 'H'))

          {

            char

              scale[32];

            if (PNMString(image,scale,sizeof(scale)) != (char *) NULL)

              quantum_scale=StringToDouble(scale,(char **) NULL);

          }

        else

          {

            if ((format == '1') || (format == '4'))

              max_value=1;  /* bitmap */

            else

              max_value=(QuantumAny) PNMInteger(image,&comment_info,10,

                exception);

          }

      }

    else

      {

        char

          keyword[MagickPathExtent],

          value[MagickPathExtent];

        int

          c;

        char

          *p;

        /*

          PAM.

        */

        for (c=ReadBlobByte(image); c != EOF; c=ReadBlobByte(image))

        {

          while (isspace((int) ((unsigned char) c)) != 0)

            c=ReadBlobByte(image);

          if (c == '#')

            {

              /*

                Comment.

              */

              while (c == '#')

              {

                c=PNMComment(image,&comment_info,exception);

                c=ReadBlobByte(image);

              }

              while (isspace((int) ((unsigned char) c)) != 0)

                c=ReadBlobByte(image);

            }

          p=keyword;

          do

          {

            if ((size_t) (p-keyword) < (MagickPathExtent-1))

              *p++=(char) c;

            c=ReadBlobByte(image);

          } while (isalnum((int) ((unsigned char) c)));

          *p='\0';

          if (LocaleCompare(keyword,"endhdr") == 0)

            break;

          while (isspace((int) ((unsigned char) c)) != 0)

            c=ReadBlobByte(image);

          p=value;

          while (isalnum((int) ((unsigned char) c)) || (c == '_'))

          {

            if ((size_t) (p-value) < (MagickPathExtent-1))

              *p++=(char) c;

            c=ReadBlobByte(image);

          }

          *p='\0';

          /*

            Assign a value to the specified keyword.

          */

          if (LocaleCompare(keyword,"depth") == 0)

            (void) StringToUnsignedLong(value);

          if (LocaleCompare(keyword,"height") == 0)

            image->rows=StringToUnsignedLong(value);

          if (LocaleCompare(keyword,"maxval") == 0)

            max_value=StringToUnsignedLong(value);

          if ((quantum_type == UndefinedQuantum) &&

              (LocaleCompare(keyword,"TUPLTYPE") == 0))

            {

              if (LocaleCompare(value,"BLACKANDWHITE") == 0)

                {

                  colorspace=GRAYColorspace;

                  quantum_type=GrayQuantum;

                }

              if (LocaleCompare(value,"BLACKANDWHITE_ALPHA") == 0)

                {

                  colorspace=GRAYColorspace;

                  image->alpha_trait=BlendPixelTrait;

                  quantum_type=GrayAlphaQuantum;

                }

              if (LocaleCompare(value,"GRAYSCALE") == 0)

                {

                  colorspace=GRAYColorspace;

                  quantum_type=GrayQuantum;

                }

              if (LocaleCompare(value,"GRAYSCALE_ALPHA") == 0)

                {

                  colorspace=GRAYColorspace;

                  image->alpha_trait=BlendPixelTrait;

                  quantum_type=GrayAlphaQuantum;

                }

              if (LocaleCompare(value,"RGB_ALPHA") == 0)

                {

                  image->alpha_trait=BlendPixelTrait;

                  quantum_type=RGBAQuantum;

                }

              if (LocaleCompare(value,"CMYK") == 0)

                {

                  colorspace=CMYKColorspace;

                  quantum_type=CMYKQuantum;

                }

              if (LocaleCompare(value,"CMYK_ALPHA") == 0)

                {

                  colorspace=CMYKColorspace;

                  image->alpha_trait=BlendPixelTrait;

                  quantum_type=CMYKAQuantum;

                }

            }

          if (LocaleCompare(keyword,"width") == 0)

            image->columns=StringToUnsignedLong(value);

        }

      }

    if (quantum_type == UndefinedQuantum)

      quantum_type=RGBQuantum;

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

      ThrowPNMException(CorruptImageError,"NegativeOrZeroImageSize");

    if ((max_value == 0) || (max_value > 4294967295UL))

      ThrowPNMException(CorruptImageError,"ImproperImageHeader");

    for (depth=1; GetQuantumRange(depth) < max_value; depth++) ;

    image->depth=depth;

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

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

        break;

    if ((MagickSizeType) (image->columns*image->rows/8) > GetBlobSize(image))

      ThrowPNMException(CorruptImageError,"InsufficientImageDataInFile");

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

    if (status == MagickFalse)

      {

        if (comment_info.comment != (char *) NULL)

          comment_info.comment=DestroyString(comment_info.comment);

        if (quantum_info != (QuantumInfo *) NULL)

          quantum_info=DestroyQuantumInfo(quantum_info);

        return(DestroyImageList(image));

      }

    if (colorspace != UndefinedColorspace)

      (void) SetImageColorspace(image,colorspace,exception);

    (void) ResetImagePixels(image,exception);

    /*

      Convert PNM pixels to runextent-encoded MIFF packets.

    */

    row=0;

    y=0;

    switch (format)

    {

      case '1':

      {

        /*

          Convert PBM image to pixel packets.

        */

        (void) SetImageColorspace(image,GRAYColorspace,exception);

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

        {

          ssize_t

            x;

          Quantum

            *magick_restrict q;

          q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);

          if (q == (Quantum *) NULL)

            break;

          for (x=0; x < (ssize_t) image->columns; x++)

          {

            SetPixelGray(image,PNMInteger(image,&comment_info,2,exception) ==

              0 ? QuantumRange : 0,q);

            if (EOFBlob(image) != MagickFalse)

              break;

            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;

            }

          if (EOFBlob(image) != MagickFalse)

            break;

        }

        image->type=BilevelType;

        break;

      }

      case '2':

      {

        Quantum

          intensity;

        /*

          Convert PGM image to pixel packets.

        */

        (void) SetImageColorspace(image,GRAYColorspace,exception);

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

        {

          ssize_t

            x;

          Quantum

            *magick_restrict q;

          q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);

          if (q == (Quantum *) NULL)

            break;

          for (x=0; x < (ssize_t) image->columns; x++)

          {

            intensity=ScaleAnyToQuantum(PNMInteger(image,&comment_info,10,

              exception),max_value);

            if (EOFBlob(image) != MagickFalse)

              break;

            SetPixelGray(image,intensity,q);

            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;

            }

          if (EOFBlob(image) != MagickFalse)

            break;

        }

        image->type=GrayscaleType;

        break;

      }

      case '3':

      {

        /*

          Convert PNM image to pixel packets.

        */

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

        {

          Quantum

            *magick_restrict q;

          ssize_t

            x;

          q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);

          if (q == (Quantum *) NULL)

            break;

          for (x=0; x < (ssize_t) image->columns; x++)

          {

            Quantum

              pixel;

            pixel=ScaleAnyToQuantum(PNMInteger(image,&comment_info,10,

              exception),max_value);

            if (EOFBlob(image) != MagickFalse)

              break;

            SetPixelRed(image,pixel,q);

            pixel=ScaleAnyToQuantum(PNMInteger(image,&comment_info,10,

              exception),max_value);

            SetPixelGreen(image,pixel,q);

            pixel=ScaleAnyToQuantum(PNMInteger(image,&comment_info,10,

              exception),max_value);

            SetPixelBlue(image,pixel,q);

            if ((is_gray != MagickFalse) &&

                (IsPixelGray(image,q) == MagickFalse))

              is_gray=MagickFalse;

            if ((is_mono != MagickFalse) &&

                (IsPixelMonochrome(image,q) == MagickFalse))

              is_mono=MagickFalse;

            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;

            }

          if (EOFBlob(image) != MagickFalse)

            break;

        }

        if (is_gray != MagickFalse)

          image->type=GrayscaleType;

        if (is_mono != MagickFalse)

          image->type=BilevelType;

        break;

      }

      case '4':

      {

        /*

          Convert PBM raw image to pixel packets.

        */

        (void) SetImageColorspace(image,GRAYColorspace,exception);

        quantum_type=GrayQuantum;

        if (image->storage_class == PseudoClass)

          quantum_type=IndexQuantum;

        quantum_info=AcquireQuantumInfo(image_info,image);

        if (quantum_info == (QuantumInfo *) NULL)

          ThrowPNMException(ResourceLimitError,"MemoryAllocationFailed");

        SetQuantumMinIsWhite(quantum_info,MagickTrue);

        extent=GetQuantumExtent(image,quantum_info,quantum_type);

        pixels=GetQuantumPixels(quantum_info);

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

        {

          MagickBooleanType

            sync;

          Quantum

            *magick_restrict q;

          ssize_t

            offset;

          size_t

            length;

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

          if (count != (ssize_t) extent)

            break;

          if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&

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

            {

              MagickBooleanType

                proceed;

              proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)

                row,image->rows);

              if (proceed == MagickFalse)

                break;

            }

          offset=row++;

          q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);

          if (q == (Quantum *) NULL)

            break;

          length=ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,

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

          if (length != extent)

            break;

          sync=SyncAuthenticPixels(image,exception);

          if (sync == MagickFalse)

            break;

        }

        quantum_info=DestroyQuantumInfo(quantum_info);

        SetQuantumImageType(image,quantum_type);

        break;

      }

      case '5':

      {

        /*

          Convert PGM raw image to pixel packets.

        */

        (void) SetImageColorspace(image,GRAYColorspace,exception);

        quantum_type=GrayQuantum;

        extent=(image->depth <= 8 ? 1 : image->depth <= 16 ? 2 : 4)*

          image->columns;

        quantum_info=AcquireQuantumInfo(image_info,image);

        if (quantum_info == (QuantumInfo *) NULL)

          ThrowPNMException(ResourceLimitError,"MemoryAllocationFailed");

        pixels=GetQuantumPixels(quantum_info);

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

        {

          const unsigned char

            *magick_restrict p;

          MagickBooleanType

            sync;

          Quantum

            *magick_restrict q;

          ssize_t

            offset,

            x;

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

          if (count != (ssize_t) extent)

            break;

          if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&

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

            {

              MagickBooleanType

                proceed;

              proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)

                row,image->rows);

              if (proceed == MagickFalse)

                break;

            }

          offset=row++;

          q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);

          if (q == (Quantum *) NULL)

            break;

          p=(unsigned char *) stream;

          switch (image->depth)

          {

            case 8:

            case 16:

            case 32:

            {

              (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info,

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

              break;

            }

            default:

            {

              switch (image->depth)

              {

                case 1:

                case 2:

                case 3:

                case 4:

                case 5:

                case 6:

                case 7:

                {

                  unsigned char

                    pixel;

                  for (x=0; x < (ssize_t) image->columns; x++)

                  {

                    p=PushCharPixel(p,&pixel);

                    SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);

                    q+=(ptrdiff_t) GetPixelChannels(image);

                  }

                  break;

                }

                case 9:

                case 10:

                case 11:

                case 12:

                case 13:

                case 14:

                case 15:

                {

                  unsigned short

                    pixel;

                  for (x=0; x < (ssize_t) image->columns; x++)

                  {

                    p=PushShortPixel(MSBEndian,p,&pixel);

                    SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);

                    q+=(ptrdiff_t) GetPixelChannels(image);

                  }

                  break;

                }

                default:

                {

                  unsigned int

                    pixel;

                  for (x=0; x < (ssize_t) image->columns; x++)

                  {

                    p=PushLongPixel(MSBEndian,p,&pixel);

                    SetPixelGray(image,ScaleAnyToQuantum(pixel,max_value),q);

                    q+=(ptrdiff_t) GetPixelChannels(image);

                  }

                  break;

                }

              }

              break;

            }

          }

          sync=SyncAuthenticPixels(image,exception);

          if (sync == MagickFalse)

            break;

        }

        quantum_info=DestroyQuantumInfo(quantum_info);

        SetQuantumImageType(image,quantum_type);

        break;

      }

      case '6':

      {

        /*

          Convert PNM raster image to pixel packets.

        */

        quantum_type=RGBQuantum;

        extent=3*(size_t) (image->depth <= 8 ? 1 : image->depth <= 16 ? 2 : 4)*

          image->columns;

        quantum_info=AcquireQuantumInfo(image_info,image);

        if (quantum_info == (QuantumInfo *) NULL)

          ThrowPNMException(ResourceLimitError,"MemoryAllocationFailed");

        (void) SetQuantumEndian(image,quantum_info,MSBEndian);

        pixels=GetQuantumPixels(quantum_info);

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

        {

          const unsigned char

            *magick_restrict p;

          MagickBooleanType

            sync;

          Quantum

            *magick_restrict q;

          ssize_t

            offset,

            x;

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

          if (count != (ssize_t) extent)

            break;

          if ((image->progress_monitor != (MagickProgressMonitor) NULL) &&

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

            {

              MagickBooleanType

                proceed;

              proceed=SetImageProgress(image,LoadImageTag,(MagickOffsetType)

                row,image->rows);

              if (proceed == MagickFalse)

                break;

            }

          offset=row++;

          q=QueueAuthenticPixels(image,0,offset,image->columns,1,exception);

          if (q == (Quantum *) NULL)

            break;

          p=(unsigned char *) stream;

          switch (image->depth)

          {

            case 1:

            case 2:

            case 3:

            case 4:

            case 5:

            case 6:

            case 7:

            {

              unsigned char

                pixel;

              for (x=0; x < (ssize_t) image->columns; x++)

              {

                p=PushCharPixel(p,&pixel);

                SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);

                p=PushCharPixel(p,&pixel);

                SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);

                p=PushCharPixel(p,&pixel);

                SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);

                SetPixelAlpha(image,OpaqueAlpha,q);

                if ((is_gray != MagickFalse) &&

                    (IsPixelGray(image,q) == MagickFalse))

                  is_gray=MagickFalse;

                if ((is_mono != MagickFalse) &&

                    (IsPixelMonochrome(image,q) == MagickFalse))

                  is_mono=MagickFalse;

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              break;

            }

            case 8:

            {

              for (x=0; x < (ssize_t) image->columns; x++)

              {

                SetPixelRed(image,ScaleCharToQuantum(*p++),q);

                SetPixelGreen(image,ScaleCharToQuantum(*p++),q);

                SetPixelBlue(image,ScaleCharToQuantum(*p++),q);

                SetPixelAlpha(image,OpaqueAlpha,q);

                if ((is_gray != MagickFalse) &&

                    (IsPixelGray(image,q) == MagickFalse))

                  is_gray=MagickFalse;

                if ((is_mono != MagickFalse) &&

                    (IsPixelMonochrome(image,q) == MagickFalse))

                  is_mono=MagickFalse;

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              break;

            }

            case 9:

            case 10:

            case 11:

            case 12:

            case 13:

            case 14:

            case 15:

            {

              unsigned short

                pixel;

              for (x=0; x < (ssize_t) image->columns; x++)

              {

                p=PushShortPixel(MSBEndian,p,&pixel);

                SetPixelRed(image,ScaleAnyToQuantum(pixel,max_value),q);

                p=PushShortPixel(MSBEndian,p,&pixel);

                SetPixelGreen(image,ScaleAnyToQuantum(pixel,max_value),q);

                p=PushShortPixel(MSBEndian,p,&pixel);

                SetPixelBlue(image,ScaleAnyToQuantum(pixel,max_value),q);

                SetPixelAlpha(image,OpaqueAlpha,q);

                if ((is_gray != MagickFalse) &&

                    (IsPixelGray(image,q) == MagickFalse))

                  is_gray=MagickFalse;

                if ((is_mono != MagickFalse) &&

                    (IsPixelMonochrome(image,q) == MagickFalse))

                  is_mono=MagickFalse;

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              break;

            }

            case 16:

            {

              unsigned short

                pixel;

              for (x=0; x < (ssize_t) image->columns; x++)

              {

                p=PushShortPixel(MSBEndian,p,&pixel);

                SetPixelRed(image,ScaleShortToQuantum(pixel),q);

                p=PushShortPixel(MSBEndian,p,&pixel);

                SetPixelGreen(image,ScaleShortToQuantum(pixel),q);

                p=PushShortPixel(MSBEndian,p,&pixel);

                SetPixelBlue(image,ScaleShortToQuantum(pixel),q);

                SetPixelAlpha(image,OpaqueAlpha,q);

                if ((is_gray != MagickFalse) &&

                    (IsPixelGray(image,q) == MagickFalse))

                  is_gray=MagickFalse;

                if ((is_mono != MagickFalse) &&

                    (IsPixelMonochrome(image,q) == MagickFalse))

                  is_mono=MagickFalse;

                q+=(ptrdiff_t) GetPixelChannels(image);

              }

              break;

            }

            case 32:

            {

              unsigned int

                pixel;

              for (x=0; x < (ssize_t) image->columns; x++)

              {

                p=PushLongPixel(MSBEndian,p,&pixel);

                SetPixelRed(image,ScaleLongToQuantum(pixel),q);

                p=PushLongPixel(MSBEndian,p,&pixel);

                SetPixelGreen(image,ScaleLongToQuantum(pixel),q);

                p=PushLongPixel(MSBEndian,p,&pixel);

                SetPixelBlue(image,ScaleLongToQuantum(pixel),q);

                SetPixelAlpha(image,OpaqueAlpha,q);

                if ((is_gray != MagickFalse) &&

                    (IsPixelGray(image,q) == MagickFalse))

                  is_gray=MagickFalse;

                if ((is_mono != MagickFalse) &&

                    (IsPixelMonochrome(image,q) == MagickFalse))