/*

% Copyright (C) 2003-2025 GraphicsMagick Group

% Copyright (C) 2002 ImageMagick Studio

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

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

%                                                                             %

%                                                                             %

%                            W   W  PPPP    GGGG                              %

%                            W   W  P   P  G                                  %

%                            W W W  PPPP   G GGG                              %

%                            WW WW  P      G   G                              %

%                            W   W  P       GGG                               %

%                                                                             %

%                                                                             %

%                       Read WordPerfect Image Format.                        %

%                                                                             %

%                                                                             %

%                              Software Design                                %

%                              Jaroslav Fojtik                                %

%                              June 2000 - 2023                               %

%                         Rework for GraphicsMagick                           %

%                              Bob Friesenhahn                                %

%                               Feb-May 2003                                  %

%                                                                             %

%                                                                             %

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

%

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#include "magick/blob.h"

#include "magick/colormap.h"

#include "magick/constitute.h"

#include "magick/log.h"

#include "magick/magic.h"

#include "magick/magick.h"

#include "magick/pixel_cache.h"

#include "magick/shear.h"

#include "magick/tempfile.h"

#include "magick/transform.h"

#include "magick/quantize.h"

#include "magick/utility.h"

#include "magick/static.h"

typedef struct

{

  unsigned char Red;

  unsigned char Blue;

  unsigned char Green;

} RGB_Record;

/* Default palette for WPG level 1 */

static const RGB_Record WPG1_Palette[256] =

  {

    {  0,  0,  0},          {  0,  0,168},

    {  0,168,  0},          {  0,168,168},

    {168,  0,  0},          {168,  0,168},

    {168, 84,  0},          {168,168,168},

    { 84, 84, 84},          { 84, 84,252},

    { 84,252, 84},          { 84,252,252},

    {252, 84, 84},          {252, 84,252},

    {252,252, 84},          {252,252,252},  /*16*/

    {  0,  0,  0},          { 20, 20, 20},

    { 32, 32, 32},          { 44, 44, 44},

    { 56, 56, 56},          { 68, 68, 68},

    { 80, 80, 80},          { 96, 96, 96},

    {112,112,112},          {128,128,128},

    {144,144,144},          {160,160,160},

    {180,180,180},          {200,200,200},

    {224,224,224},          {252,252,252},  /*32*/

    {  0,  0,252},          { 64,  0,252},

    {124,  0,252},          {188,  0,252},

    {252,  0,252},          {252,  0,188},

    {252,  0,124},          {252,  0, 64},

    {252,  0,  0},          {252, 64,  0},

    {252,124,  0},          {252,188,  0},

    {252,252,  0},          {188,252,  0},

    {124,252,  0},          { 64,252,  0},  /*48*/

    {  0,252,  0},          {  0,252, 64},

    {  0,252,124},          {  0,252,188},

    {  0,252,252},          {  0,188,252},

    {  0,124,252},          {  0, 64,252},

    {124,124,252},          {156,124,252},

    {188,124,252},          {220,124,252},

    {252,124,252},          {252,124,220},

    {252,124,188},          {252,124,156},  /*64*/

    {252,124,124},          {252,156,124},

    {252,188,124},          {252,220,124},

    {252,252,124},          {220,252,124},

    {188,252,124},          {156,252,124},

    {124,252,124},          {124,252,156},

    {124,252,188},          {124,252,220},

    {124,252,252},          {124,220,252},

    {124,188,252},          {124,156,252},  /*80*/

    {180,180,252},          {196,180,252},

    {216,180,252},          {232,180,252},

    {252,180,252},          {252,180,232},

    {252,180,216},          {252,180,196},

    {252,180,180},          {252,196,180},

    {252,216,180},          {252,232,180},

    {252,252,180},          {232,252,180},

    {216,252,180},          {196,252,180},  /*96*/

    {180,220,180},          {180,252,196},

    {180,252,216},          {180,252,232},

    {180,252,252},          {180,232,252},

    {180,216,252},          {180,196,252},

    {0,0,112},              {28,0,112},

    {56,0,112},             {84,0,112},

    {112,0,112},            {112,0,84},

    {112,0,56},             {112,0,28},     /*112*/

    {112,0,0},              {112,28,0},

    {112,56,0},             {112,84,0},

    {112,112,0},            {84,112,0},

    {56,112,0},             {28,112,0},

    {0,112,0},              {0,112,28},

    {0,112,56},             {0,112,84},

    {0,112,112},            {0,84,112},

    {0,56,112},             {0,28,112},     /*128*/

    {56,56,112},            {68,56,112},

    {84,56,112},            {96,56,112},

    {112,56,112},           {112,56,96},

    {112,56,84},            {112,56,68},

    {112,56,56},            {112,68,56},

    {112,84,56},            {112,96,56},

    {112,112,56},           {96,112,56},

    {84,112,56},            {68,112,56},    /*144*/

    {56,112,56},            {56,112,69},

    {56,112,84},            {56,112,96},

    {56,112,112},           {56,96,112},

    {56,84,112},            {56,68,112},

    {80,80,112},            {88,80,112},

    {96,80,112},            {104,80,112},

    {112,80,112},           {112,80,104},

    {112,80,96},            {112,80,88},    /*160*/

    {112,80,80},            {112,88,80},

    {112,96,80},            {112,104,80},

    {112,112,80},           {104,112,80},

    {96,112,80},            {88,112,80},

    {80,112,80},            {80,112,88},

    {80,112,96},            {80,112,104},

    {80,112,112},           {80,114,112},

    {80,96,112},            {80,88,112},    /*176*/

    {0,0,64},               {16,0,64},

    {32,0,64},              {48,0,64},

    {64,0,64},              {64,0,48},

    {64,0,32},              {64,0,16},

    {64,0,0},               {64,16,0},

    {64,32,0},              {64,48,0},

    {64,64,0},              {48,64,0},

    {32,64,0},              {16,64,0},      /*192*/

    {0,64,0},               {0,64,16},

    {0,64,32},              {0,64,48},

    {0,64,64},              {0,48,64},

    {0,32,64},              {0,16,64},

    {32,32,64},             {40,32,64},

    {48,32,64},             {56,32,64},

    {64,32,64},             {64,32,56},

    {64,32,48},             {64,32,40},     /*208*/

    {64,32,32},             {64,40,32},

    {64,48,32},             {64,56,32},

    {64,64,32},             {56,64,32},

    {48,64,32},             {40,64,32},

    {32,64,32},             {32,64,40},

    {32,64,48},             {32,64,56},

    {32,64,64},             {32,56,64},

    {32,48,64},             {32,40,64},     /*224*/

    {44,44,64},             {48,44,64},

    {52,44,64},             {60,44,64},

    {64,44,64},             {64,44,60},

    {64,44,52},             {64,44,48},

    {64,44,44},             {64,48,44},

    {64,52,44},             {64,60,44},

    {64,64,44},             {60,64,44},

    {52,64,44},             {48,64,44},     /*240*/

    {44,64,44},             {44,64,48},

    {44,64,52},             {44,64,60},

    {44,64,64},             {44,60,64},

    {44,55,64},             {44,48,64},

    {0,0,0},                {0,0,0},

    {0,0,0},                {0,0,0},

    {0,0,0},                {0,0,0},

    {0,0,0},                {0,0,0}         /*256*/

  };

static int ApproveFormatForWPG(const char *Format, ExceptionInfo *exception)

{

  const MagickInfo *

    magick_info;

  if (!strcmp(Format,"PFB")) return 0;

  /*if (!strcmp(Format,"8BIMTEXT")) return 0; This test is no longer needed, META module includes this case. */

  magick_info = GetMagickInfo(Format,exception);

  if (magick_info != (const MagickInfo *)NULL)

    {

      if (strcmp(magick_info->module, "META") == 0) return 0;

    }

  return 1;

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   I s W P G                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  IsWPG() returns True if the image format type, identified by the magick

%  string, is WPG.

%

%  The format of the IsWPG method is:

%

%      unsigned int IsWPG(const unsigned char *magick,const size_t length)

%

%  A description of each parameter follows:

%

%    o status:  Method IsWPG returns True if the image format type is WPG.

%

%    o magick: This string is generally the first few bytes of an image file

%      or blob.

%

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

%

%

*/

static unsigned int IsWPG(const unsigned char *magick,const size_t length)

{

  if (length < 4)

    return(False);

  if (memcmp(magick,"\377WPC",4) == 0)

    return(True);

  return(False);

}

static int Rd_WP_DWORD(Image *image, magick_uint32_t *d)

{

  unsigned char

    b;

  b = ReadBlobByte(image);

  *d = b;

  if (b < 0xFFU)

    return 1;

  b = ReadBlobByte(image);

  *d = (unsigned long) b;

  b = ReadBlobByte(image);

  *d+=(unsigned long) b*256l;

  if (*d < 0x8000)

    return 3;

  *d=(*d & 0x7FFF) << 16;

  b = ReadBlobByte(image);

  *d += (unsigned long) b;

  b=ReadBlobByte(image);

  *d += (unsigned long) b*256l;

  return 5;

}

static MagickPassFail InsertRow(unsigned char *p,unsigned long y, Image *image, int bpp)

{

  unsigned long

    x;

  register PixelPacket

    *q;

  MagickPassFail

    RetVal = MagickFail;

  IndexPacket

    index;

  IndexPacket *

    indexes;

  if (image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "Insert row %ld of %lu...", y, image->rows);

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

  if (q == (PixelPacket *) NULL)

    return MagickFail;

  switch (bpp)

    {

    case 1:  /* Convert bitmap scanline. WP seems to ignore palette even if it is present. */

      RetVal = ImportImagePixelArea(image,GrayQuantum,bpp,p,NULL,0);

      break;

    case 4:  /* Convert PseudoColor scanline. */

    case 8:  /* Convert PseudoColor scanline. */

      RetVal = ImportImagePixelArea(image,IndexQuantum,bpp,p,NULL,0);

      break;

    case 2:  /* Convert PseudoColor scanline. */

      {

        indexes=AccessMutableIndexes(image);

        if ((image->storage_class != PseudoClass) ||

            (indexes == (IndexPacket *) NULL))

          {

            if (image->logging)

              (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                    "Image has no colormap, skipping...");

            return MagickFail;

          }

        x = 0;

        while (x+3 < image->columns)

          {

            index = (IndexPacket)((*p >> 6) & 0x3);

            VerifyColormapIndex(image,index);

            indexes[x++]=index;

            *q++=image->colormap[index];

            index = (IndexPacket)((*p >> 4) & 0x3);

            VerifyColormapIndex(image,index);

            indexes[x++]=index;

            *q++=image->colormap[index];

            index = (IndexPacket)((*p >> 2) & 0x3);

            VerifyColormapIndex(image,index);

            indexes[x++]=index;

            *q++ = image->colormap[index];

            index = (IndexPacket)((*p) & 0x3);

            VerifyColormapIndex(image,index);

            indexes[x++]=index;

            *q++ = image->colormap[index];

            p++;

          }

        if (x < image->columns)

          {

            index = (IndexPacket) ((*p >> 6) & 0x3);

            VerifyColormapIndex(image,index);

            indexes[x++] = index;

            *q++=image->colormap[index];

            if (x < image->columns)

              {

                index = (IndexPacket) ((*p >> 4) & 0x3);

                VerifyColormapIndex(image,index);

                indexes[x++] = index;

                *q++=image->colormap[index];

                if (x < image->columns)

                  {

                    index = (IndexPacket)((*p >> 2) & 0x3);

                    VerifyColormapIndex(image,index);

                    indexes[x] = index;

                    *q++=image->colormap[index];

                  }

              }

            /* p++; */

          }

        RetVal = MagickPass;

        break;

      }

    case 24:     /*  Convert DirectColor scanline.  */

      RetVal = ImportImagePixelArea(image,RGBQuantum,8,p,NULL,0);

      break;

    default:

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "Unsupported bits per pixel %u",bpp);

      return MagickFail;  /* emit some error here */

    }

  if (RetVal==MagickFail)

    {

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),"ImportImagePixelArea failed for row: %lu, bpp: %d", y, bpp);

      return MagickFail;

    }

  if (!SyncImagePixels(image))

    {

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),"SyncImagePixels failed for row: %ld, bpp: %d", y, bpp);

      return MagickFail;

    }

  return RetVal;

}

/* Helper for WPG1 raster reader. */

#define InsertByte(b)                                                   \

  {                                                                     \

    BImgBuff[x]=b;                                                      \

    x++;                                                                \

    if ((long) x>=ldblk)                                                \

      {                                                                 \

        if (InsertRow(BImgBuff,y,image,bpp)==MagickFail)                \

          {                                                             \

            RetVal=-6;                                                  \

            goto unpack_wpg_raser_error;                                \

          }                                                             \

        x=0;                                                            \

        y++;                                                            \

        if (y>=image->rows) break;                                      \

      }                                                                 \

}

/** Call this function to ensure that all data matrix is filled with something. This function

 * is used only to error recovery. */

static MagickPassFail ZeroFillMissingData(unsigned char *BImgBuff,

                                          unsigned long x,

                                          unsigned long y,

                                          Image *image,

                                          int bpp,

                                          long ldblk)

{

  MagickPassFail

    status = MagickPass;

  while (y<image->rows && image->exception.severity!=UndefinedException)

    {

      if ((long) x<ldblk)

        {

          memset(BImgBuff+x, 0, (size_t)ldblk-(size_t)x);

          if (x == 0)

            x = ldblk;      /* Do not memset any more */

          else

            x = 0;          /* Next pass will need to clear whole row */

        }

      if (InsertRow(BImgBuff,y,image,bpp) == MagickFail)

        {

          status = MagickFail;

          break;

        }

      y++;

    }

  return status;

}

/* WPG1 raster reader.

 * @return      0 - OK; -2 - allocation failure; -3 unaligned column; -4 - image row overflowl

                -5 - blob read error; -6 - row insert problem  */

static int UnpackWPGRaster(Image *image,int bpp)

{

  unsigned long

    x = 0,

    y = 0;

  int

    i;

  int RetVal

    = 0;

  unsigned char

    bbuf,

    *BImgBuff,

    RunCount;

  long

    ldblk;

  ldblk = (long)((bpp*image->columns+7)/8);

  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                        "Raster allocation size: %ld byte%s",

                        ldblk, (ldblk > 1 ? "s" : ""));

  BImgBuff=MagickAllocateResourceLimitedMemory(unsigned char *,(size_t) ldblk);

  if (BImgBuff==NULL)

    return(-2);

  (void) memset(BImgBuff,0,(size_t) ldblk);

  while (y<image->rows)

    {

      i = ReadBlobByte(image);

      if (i==EOF)

        {

          ZeroFillMissingData(BImgBuff,x,y,image,bpp,ldblk);

          MagickFreeResourceLimitedMemory(unsigned char *,BImgBuff);

          return(-5);

        }

      bbuf = i;

      RunCount=bbuf & 0x7F;

      if (bbuf & 0x80)

        {

          if (RunCount)  /* repeat next byte runcount * */

            {

              bbuf=ReadBlobByte(image);

              for (i=0;i<(int) RunCount;i++) InsertByte(bbuf);

            }

          else {  /* read next byte as RunCount; repeat 0xFF runcount* */

            RunCount=ReadBlobByte(image);

            for (i=0;i<(int) RunCount;i++) InsertByte(0xFF);

          }

        }

      else {

        if (RunCount)   /* next runcount byte are readd directly */

          {

            for (i=0;i < (int) RunCount;i++)

              {

                bbuf=ReadBlobByte(image);

                InsertByte(bbuf);

              }

          }

        else {  /* repeat previous line runcount* */

          i = ReadBlobByte(image);

          if (i==EOF)

            {

              ZeroFillMissingData(BImgBuff,x,y,image,bpp,ldblk);

              MagickFreeResourceLimitedMemory(unsigned char *,BImgBuff);

              return -7;

            }

          RunCount = i;

          if (x!=0) {    /* attempt to duplicate row from x position: */

            /* I do not know what to do here */

            if (InsertRow(BImgBuff,y,image,bpp) == MagickPass)   /* May be line flush can fix a situation. */

              {

                x=0;

                y++;

                ZeroFillMissingData(BImgBuff,x,y,image,bpp,ldblk);

              }

            MagickFreeResourceLimitedMemory(unsigned char *,BImgBuff);

            return(-3);

          }

          for (i=0; i<(int)RunCount; i++)

            {           /* Here I need to duplicate previous row RUNCOUNT* */

                        /* when x=0; y points to a new empty line. For y=0 zero line will be populated. */

              if (y>=image->rows)

                {

                  MagickFreeResourceLimitedMemory(unsigned char *,BImgBuff);

                  return(-4);

                }

              if (InsertRow(BImgBuff,y,image,bpp)==MagickFail)

                {

                  MagickFreeResourceLimitedMemory(unsigned char *,BImgBuff);

                  return(-6);

                }

              y++;

            }

        }

      }

    }

 unpack_wpg_raser_error:;

  MagickFreeResourceLimitedMemory(unsigned char *,BImgBuff);

  return(RetVal);

}

/* Helper for WPG2 reader. */

#define InsertByte6(b)                                          \

  {                                                             \

    if (XorMe)                                                  \

      BImgBuff[x] = b ^ UpImgBuff[x];                           \

    else                                                        \

      BImgBuff[x] = b;                                          \

    x++;                                                        \

    if ((long) x >= ldblk)                                      \

      {                                                         \

        if (InsertRow(BImgBuff,(long) y,image,bpp)==MagickFail) \

          { RetVal=-6;                                          \

            goto unpack_wpg2_error;                             \

          }                                                     \

        x=0;                                                    \

        y++;                                                    \

        XorMe = 0;                                              \

        tmpImgBuff = BImgBuff;                                  \

        BImgBuff = UpImgBuff;                                   \

        UpImgBuff = tmpImgBuff;                                 \

      }                                                         \

  }

#define FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff)                 \

  do                                                                   \

    {                                                                  \

      MagickFreeResourceLimitedMemory(unsigned char *,BImgBuff);       \

      MagickFreeResourceLimitedMemory(unsigned char *,UpImgBuff);      \

    } while (0);

/* WPG2 raster reader. */

static int UnpackWPG2Raster(Image *image, int bpp)

{

  unsigned int

    SampleSize=1;

  unsigned char

    bbuf,

    *BImgBuff = (unsigned char *) NULL,   /* Buffer for a current line. */

    *UpImgBuff = (unsigned char *) NULL,  /* Buffer for previous line. */

    *tmpImgBuff = (unsigned char *) NULL,

    RunCount,

    SampleBuffer[8];

  unsigned long

    x = 0,

    y = 0;

  unsigned int

    i;

  long

    ldblk;

  int XorMe = 0;

  int c;

  int RetVal = 0;

  ldblk=(long) ((bpp*image->columns+7)/8);

  BImgBuff=MagickAllocateResourceLimitedMemory(unsigned char *,(size_t) ldblk);

  if (BImgBuff==NULL)

    return(-2);

  UpImgBuff=MagickAllocateResourceLimitedMemory(unsigned char *,(size_t) ldblk);

  if (UpImgBuff==NULL)

    {

      FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

      return(-2);

    }

  (void) memset(UpImgBuff,0,ldblk);

  (void) memset(SampleBuffer,0,sizeof(SampleBuffer));

  while ( y< image->rows)

    {

      bbuf=ReadBlobByte(image);

      switch (bbuf)

        {

        case 0x7D:

          if ((c = ReadBlobByte(image)) == EOF) /* DSZ */

            {

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-4);

            }

          SampleSize=c;

          if (SampleSize>8)

            {

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-2);

            }

          if (SampleSize<1)

            {

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-2);

            }

          break;

        case 0x7E:

          if (y==0)                         /* XOR */

            (void)fprintf(stderr,"\nWPG token XOR on the first line is not supported, please report!");

          XorMe=!XorMe; /* or XorMe=1 ?? */

          break;

        case 0x7F:

          if ((c = ReadBlobByte(image)) == EOF) /* BLK */

            {

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-4);

            }

          RunCount=c;

          for (i=0; i < SampleSize*(RunCount+1); i++)

            {

              InsertByte6(0);

            }

          break;

        case 0xFD:

          if ((c = ReadBlobByte(image)) == EOF) /* EXT */

            {

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-4);

            }

          RunCount=c;

          for (i=0; i<= RunCount;i++)

            for (bbuf=0; bbuf < SampleSize; bbuf++)

              InsertByte6(SampleBuffer[bbuf]);

          break;

        case 0xFE:

          if ((c = ReadBlobByte(image)) == EOF)  /* RST */

            {

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-4);

            }

          RunCount = c;

          if (x!=0)

            {

              (void) fprintf(stderr,

                             "\nUnsupported WPG2 unaligned token RST x=%lu, please report!\n"

                             ,x);

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-3);

            }

          {

            /* duplicate the previous row RunCount x */

            for (i=0;i<=RunCount;i++)

              {

                if (InsertRow(UpImgBuff,(long)((image->rows>y) ? y : image->rows-1),image,bpp) == MagickFail)

                  {

                    FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

                    return(-4);

                  }

                y++;

              }

          }

          break;

        case 0xFF:

          if ((c = ReadBlobByte(image)) == EOF)  /* WHT */

            {

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-4);

            }

          RunCount=c;

          for (i=0; i < SampleSize*(RunCount+1); i++)

            {

              InsertByte6(0xFF);

            }

          break;

        default:

          RunCount=bbuf & 0x7F;

          if (bbuf & 0x80)                /* REP */

            {

              for (i=0; i < SampleSize; i++)

                SampleBuffer[i]=ReadBlobByte(image);

              for (i=0;i<=RunCount;i++)

                for (bbuf=0;bbuf<SampleSize;bbuf++)

                  InsertByte6(SampleBuffer[bbuf]);

            }

          else {                        /* NRP */

            for (i=0; i< SampleSize*(RunCount+1);i++)

              {

                bbuf=ReadBlobByte(image);

                InsertByte6(bbuf);

              }

          }

          if (EOFBlob(image))

            {

              FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

              return(-4);

            }

        }

    }

 unpack_wpg2_error:;

  FreeUnpackWPG2RasterAllocs(BImgBuff,UpImgBuff);

  return(RetVal);

}

typedef float tCTM[3][3];

static unsigned LoadWPG2Flags(Image *image, char Precision, float *Angle, tCTM *CTM)

{

  const unsigned char

    TPR=1,

    TRN=2,

    SKW=4,

    SCL=8,

    ROT=0x10,

    OID=0x20,

    LCK=0x80;

  long

    x;

  unsigned

    DenX;

  unsigned

    Flags;

  (void) memset(*CTM,0,sizeof(*CTM));     /*CTM.erase();CTM.resize(3,3);*/

  (*CTM)[0][0]=1;

  (*CTM)[1][1]=1;

  (*CTM)[2][2]=1;

  Flags=ReadBlobLSBShort(image);

  if (Flags & LCK) /*x=*/

    (void)ReadBlobLSBLong(image);  /*Edit lock*/

  if (Flags & OID)

    {

      if (Precision==0)

        {

          x = ReadBlobLSBShort(image);

          if (x >= 0x8000)

            {

              Precision = 1;   /* Double precision Switched on. */

              (void) ReadBlobLSBShort(image);

              /* ObjectId = ((xW & 0x7FFF)<<16) | DenX; */

            }

        }      /*ObjectID*/

      else

        {/*x=*/ (void) ReadBlobLSBLong(image);}  /*ObjectID native (Double precision)*/

    }

  if (Flags & ROT)

    {

      x=ReadBlobLSBLong(image);       /*Rot Angle*/

      if (Angle)

        *Angle=(float) (x/65536.0);

    }

  if (Flags & (ROT|SCL))

    {

      x=ReadBlobLSBLong(image);       /*Sx*cos()*/

      (*CTM)[0][0] = (float)x/0x10000;

      x=ReadBlobLSBLong(image);       /*Sy*cos()*/

      (*CTM)[1][1] = (float)x/0x10000;

    }

  if (Flags & (ROT|SKW))

    {

      x=ReadBlobLSBLong(image);       /*Kx*sin()*/

      (*CTM)[1][0] = (float)x/0x10000;

      x=ReadBlobLSBLong(image);       /*Ky*sin()*/

      (*CTM)[0][1] = (float)x/0x10000;

    }

  if (Flags & TRN)

    {

      DenX=ReadBlobLSBShort(image); x=ReadBlobLSBLong(image);  /*Tx*/

      (*CTM)[0][2] = (double)x + (float)DenX/0x10000;

      DenX=ReadBlobLSBShort(image); x=ReadBlobLSBLong(image);  /*Ty*/

      (*CTM)[1][2] = (double)x + (float)DenX/0x10000;

    }

  if (Flags & TPR)

    {

      x=ReadBlobLSBShort(image); DenX=ReadBlobLSBShort(image);  /*Px*/

      (*CTM)[2][0] = x + (float)DenX/0x10000;;

      x=ReadBlobLSBShort(image);  DenX=ReadBlobLSBShort(image); /*Py*/

      (*CTM)[2][1] = x + (float)DenX/0x10000;

    }

  return (Flags);

}

static Image *ExtractPostscript(Image *image,const ImageInfo *image_info,

                                ExtendedSignedIntegralType PS_Offset,

                                size_t PS_Size,ExceptionInfo *exception)

{

  ImageInfo

    *clone_info;

  Image

    *image2;

  unsigned char

    header_magick[2*MaxTextExtent];

  void

    *ps_data,

    *ps_data_alloc = (unsigned char *) NULL;

  char

    format[MaxTextExtent];

  size_t

    header_magick_size;

  magick_off_t

    filesize;

  if (image->logging)

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                          "ExtractPostscript(): PS_Offset=%" MAGICK_OFF_F "d, PS_Size=%" MAGICK_SIZE_T_F "u",

                          (magick_off_t) PS_Offset, (MAGICK_SIZE_T) PS_Size);

  /*

    Validate that claimed subordinate image data is contained in file size

  */

  filesize = GetBlobSize(image);

  if ((PS_Offset > filesize) || ((size_t) (filesize - PS_Offset) < PS_Size))

    {

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "ExtractPostscript(): Failed to seek to PS_Offset=%" MAGICK_OFF_F "d",

                              (magick_off_t) PS_Offset);

      ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,image->filename);

      return image;

    }

  /*

    Get subordinate file header magick and use it to identify file format

  */

  if (SeekBlob(image,PS_Offset,SEEK_SET) != PS_Offset)

    {

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "ExtractPostscript(): Failed to seek to PS_Offset=%" MAGICK_OFF_F "d",

                              (magick_off_t) PS_Offset);

      ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,image->filename);

      return image;

    }

  header_magick_size = ReadBlob(image, Min(sizeof(header_magick),PS_Size), header_magick);

  format[0]='\0';

  /*

    MagickExport MagickPassFail

    GetMagickFileFormat(const unsigned char *header, const size_t header_length,

    char *format, const size_t format_length,

    ExceptionInfo *exception)

  */

  if (GetMagickFileFormat(header_magick,header_magick_size,format,

                          sizeof(format),exception) == MagickFail)

    {

      (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                            "Failed to identify embedded file type!");

      ThrowException(exception,CorruptImageError,UnableToReadImageHeader,image->filename);

      return image;

    }

  /*

    Verify if this is an allowed subordinate image format

  */

  if (!ApproveFormatForWPG(format,exception))

    {

      (void) LogMagickEvent(CoderEvent, GetMagickModule(),

                            "Format \"%s\" cannot be embedded inside WPG.", format);

      ThrowException(exception,CorruptImageError,UnableToReadImageHeader,image->filename);

      return image;

    }

  /*

    Restore seek offset after reading header

  */

  if (SeekBlob(image,PS_Offset,SEEK_SET) != PS_Offset)

    {

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "ExtractPostscript(): Failed to seek to PS_Offset=%" MAGICK_OFF_F "d",

                              (magick_off_t) PS_Offset);

      ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,image->filename);

      return image;

    }

  /*

    Allocate buffer if zero-copy read is not possible.

  */

  if (GetBlobStreamData(image) == (unsigned char *) NULL)

    {

      ps_data_alloc=MagickAllocateResourceLimitedMemory(unsigned char *, PS_Size);

      if (ps_data_alloc == (unsigned char *) NULL)

        {

          if (image->logging)

            (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                  "ExtractPostscript(): Failed to allocate "

                                  "%" MAGICK_SIZE_T_F "u bytes of memory",

                                  (MAGICK_SIZE_T) PS_Size);

          ThrowException(exception,ResourceLimitError,MemoryAllocationFailed,image->filename);

          return image;

        }

    }

  /*

    Use a zero-copy read when possible to access data

  */

  ps_data=ps_data_alloc;

  if (ReadBlobZC(image,PS_Size,&ps_data) != PS_Size)

    {

      MagickFreeResourceLimitedMemory(unsigned char *,ps_data_alloc);

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "ExtractPostscript(): Failed to read %" MAGICK_SIZE_T_F "u bytes of data at"

                              " offset=%" MAGICK_OFF_F "d",

                              (MAGICK_SIZE_T) PS_Size, (magick_off_t) PS_Offset);

      ThrowException(exception,CorruptImageError,UnexpectedEndOfFile,image->filename);

      return image; /* return (Image *) NULL; */

    }

  if (ps_data_alloc != ps_data)

    {

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                              "ExtractPostscript(): Zero copy read.");

    }

#if 0

  /*

    Write in-memory blob to file for test purposes.

  */

  {

    char file_name[MaxTextExtent];

    FILE *file;

    FormatString(file_name,"wpg-blob.%s",format);

    if ((file=fopen(file_name,"w")) != (FILE *) NULL)

      {

        if (image->logging)

          (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                                "Writing %s...", file_name);

        (void) fwrite(ps_data, 1, PS_Size, file);

        (void) fclose(file);

      }

    SeekBlob(image,PS_Offset,SEEK_SET);

  }

#endif

  /*

    Read nested image from blob, forcing read as Postscript format

  */

  if ((clone_info=CloneImageInfo(image_info)) == NULL)

    {

      MagickFreeResourceLimitedMemory(unsigned char *,ps_data_alloc);

      return(image);

    }

  clone_info->blob=(_BlobInfoPtr_) NULL;

  /* clone_info->length=0; */

  (void) strlcpy(clone_info->magick, format, sizeof(clone_info->magick));

  (void) strlcpy(clone_info->filename, "", sizeof(clone_info->filename));

  (void) LogMagickEvent(CoderEvent,GetMagickModule(),

                        "Reading embedded \"%s\" content from blob...", clone_info->magick);

  image2 = BlobToImage(clone_info, ps_data, PS_Size, &image->exception );

  MagickFreeResourceLimitedMemory(unsigned char *,ps_data_alloc);

  if (!image2)

    {

      goto FINISH_UNL;

    }

  if (exception->severity >= ErrorException) /* When exception is raised, destroy image2 read. */

    {

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Exception raised during embedded image reading.");

      CloseBlob(image2);

      DestroyImageList(image2);

      goto FINISH_UNL;

    }

  if (!GetPixelCachePresent(image2))

    {

      if (image->logging)

        (void) LogMagickEvent(CoderEvent,GetMagickModule(), "Pixel cache is missing for embedded image.");

      CloseBlob(image2);

      DestroyImageList(image2);

      goto FINISH_UNL;

    }

  /*

    Replace current image with new image while copying base image