/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%                            SSSSS  V   V   GGGG                              %

%                            SS     V   V  G                                  %

%                             SSS   V   V  G GG                               %

%                               SS   V V   G   G                              %

%                            SSSSS    V     GGG                               %

%                                                                             %

%                                                                             %

%                  Read/Write Scalable Vector Graphics Format                 %

%                                                                             %

%                              Software Design                                %

%                                   Cristy                                    %

%                             William Radcliffe                               %

%                                March 2000                                   %

%                                                                             %

%                                                                             %

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

#include "MagickCore/artifact.h"

#include "MagickCore/attribute.h"

#include "MagickCore/blob.h"

#include "MagickCore/blob-private.h"

#include "MagickCore/cache.h"

#include "MagickCore/constitute.h"

#include "MagickCore/composite-private.h"

#include "MagickCore/delegate.h"

#include "MagickCore/delegate-private.h"

#include "MagickCore/draw.h"

#include "MagickCore/exception.h"

#include "MagickCore/exception-private.h"

#include "MagickCore/gem.h"

#include "MagickCore/image.h"

#include "MagickCore/image-private.h"

#include "MagickCore/list.h"

#include "MagickCore/log.h"

#include "MagickCore/magick.h"

#include "MagickCore/memory_.h"

#include "MagickCore/memory-private.h"

#include "MagickCore/module.h"

#include "MagickCore/monitor.h"

#include "MagickCore/monitor-private.h"

#include "MagickCore/nt-base-private.h"

#include "MagickCore/option.h"

#include "MagickCore/pixel-accessor.h"

#include "MagickCore/policy.h"

#include "MagickCore/property.h"

#include "MagickCore/quantum-private.h"

#include "MagickCore/resource_.h"

#include "MagickCore/static.h"

#include "MagickCore/string_.h"

#include "MagickCore/string-private.h"

#include "MagickCore/thread-private.h"

#include "MagickCore/token.h"

#include "MagickCore/utility.h"

#include "coders/coders-private.h"

#if defined(MAGICKCORE_XML_DELEGATE)

#  include <libxml/xmlmemory.h>

#  include <libxml/parserInternals.h>

#  include <libxml/xmlerror.h>

#endif

#if defined(MAGICKCORE_AUTOTRACE_DELEGATE)

#include "autotrace/autotrace.h"

#endif

#if defined(MAGICKCORE_RSVG_DELEGATE)

#include "librsvg/rsvg.h"

#if !defined(LIBRSVG_CHECK_VERSION)

#include "librsvg/rsvg-cairo.h"

#include "librsvg/librsvg-features.h"

#elif !LIBRSVG_CHECK_VERSION(2,36,2)

#include "librsvg/rsvg-cairo.h"

#include "librsvg/librsvg-features.h"

#endif

#endif

/*

  Define declarations.

*/

#define DefaultSVGDensity  96.0

/*

  Typedef declarations.

*/

typedef struct _BoundingBox

{

  double

    x,

    y,

    width,

    height;

} BoundingBox;

typedef struct _ElementInfo

{

  double

    cx,

    cy,

    major,

    minor,

    angle;

} ElementInfo;

typedef struct _SVGInfo

{

  FILE

    *file;

  ExceptionInfo

    *exception;

  Image

    *image;

  const ImageInfo

    *image_info;

  AffineMatrix

    affine;

  size_t

    width,

    height;

  char

    *size,

    *title,

    *comment;

  int

    n;

  double

    *scale,

    pointsize;

  ElementInfo

    element;

  SegmentInfo

    segment;

  BoundingBox

    bounds,

    text_offset,

    view_box;

  PointInfo

    radius;

  char

    *stop_color,

    *offset,

    *text,

    *vertices,

    *url;

  ssize_t

    svgDepth;

} SVGInfo;

/*

  Global declarations.

*/

#if defined(MAGICKCORE_RSVG_DELEGATE)

static SemaphoreInfo

  *rsvg_semaphore = (SemaphoreInfo *) NULL;

#endif

static SplayTreeInfo

  *svg_tree = (SplayTreeInfo *) NULL;

/*

  Static declarations.

*/

static char

  SVGDensityGeometry[] = "96.0x96.0";

/*

  Forward declarations.

*/

static MagickBooleanType

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

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   I s S V G                                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

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

%  magick string, is SVG.

%

%  The format of the IsSVG method is:

%

%      MagickBooleanType IsSVG(const unsigned char *magick,const size_t length)

%

%  A description of each parameter follows:

%

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

%

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

%

*/

static MagickBooleanType IsSVG(const unsigned char *magick,const size_t length)

{

  if (length < 4)

    return(MagickFalse);

  if (LocaleNCompare((const char *) magick+1,"svg",3) == 0)

    return(MagickTrue);

  if (length < 5)

    return(MagickFalse);

  if (LocaleNCompare((const char *) magick+1,"?xml",4) == 0)

    return(MagickTrue);

  return(MagickFalse);

}

/*

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

%                                                                             %

%                                                                             %

%                                                                             %

%   R e a d S V G I m a g e                                                   %

%                                                                             %

%                                                                             %

%                                                                             %

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

%

%  ReadSVGImage() reads a Scalable Vector Graphics 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 ReadSVGImage method is:

%

%      Image *ReadSVGImage(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 *RenderSVGImage(const ImageInfo *image_info,Image *image,

  ExceptionInfo *exception)

{

  char

    background[MagickPathExtent],

    command[MagickPathExtent],

    *density,

    input_filename[MagickPathExtent],

    opacity[MagickPathExtent],

    output_filename[MagickPathExtent],

    unique[MagickPathExtent];

  const DelegateInfo

    *delegate_info;

  Image

    *next;

  int

    status;

  struct stat

    attributes;

  /*

    Our best hope for compliance with the SVG standard.

  */

  delegate_info=GetDelegateInfo("svg:decode",(char *) NULL,exception);

  if (delegate_info == (const DelegateInfo *) NULL)

    return((Image *) NULL);

  if (AcquireUniqueSymbolicLink(image->filename,input_filename) == MagickFalse)

    return((Image *) NULL);

  (void) AcquireUniqueFilename(unique);

  (void) FormatLocaleString(output_filename,MagickPathExtent,"%s.png",unique);

  (void) RelinquishUniqueFileResource(unique);

  density=AcquireString("");

  (void) FormatLocaleString(density,MagickPathExtent,"%.20g",

    sqrt(image->resolution.x*image->resolution.y));

  (void) FormatLocaleString(background,MagickPathExtent,

    "rgb(%.20g%%,%.20g%%,%.20g%%)",

    100.0*QuantumScale*image->background_color.red,

    100.0*QuantumScale*image->background_color.green,

    100.0*QuantumScale*image->background_color.blue);

  (void) FormatLocaleString(opacity,MagickPathExtent,"%.20g",QuantumScale*

    image->background_color.alpha);

  (void) FormatLocaleString(command,MagickPathExtent,

    GetDelegateCommands(delegate_info),input_filename,output_filename,density,

    background,opacity);

  density=DestroyString(density);

  status=ExternalDelegateCommand(MagickFalse,image_info->verbose,command,

    (char *) NULL,exception);

  (void) RelinquishUniqueFileResource(input_filename);

  if ((status == 0) && (stat(output_filename,&attributes) == 0) &&

      (attributes.st_size > 0))

    {

      Image

        *svg_image;

      ImageInfo

        *read_info;

      read_info=CloneImageInfo(image_info);

      (void) CopyMagickString(read_info->filename,output_filename,

        MagickPathExtent);

      svg_image=ReadImage(read_info,exception);

      read_info=DestroyImageInfo(read_info);

      if (svg_image != (Image *) NULL)

        {

          (void) RelinquishUniqueFileResource(output_filename);

          for (next=GetFirstImageInList(svg_image); next != (Image *) NULL; )

          {

            (void) CopyMagickString(next->filename,image->filename,

              MagickPathExtent);

            (void) CopyMagickString(next->magick,image->magick,

              MagickPathExtent);

            next=GetNextImageInList(next);

          }

          return(svg_image);

        }

    }

  (void) RelinquishUniqueFileResource(output_filename);

  return((Image *) NULL);

}

#if defined(MAGICKCORE_RSVG_DELEGATE)

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

  ExceptionInfo *exception)

{

#if defined(MAGICKCORE_CAIRO_DELEGATE)

  cairo_surface_t

    *cairo_surface;

  cairo_t

    *cairo_image;

  MagickBooleanType

    apply_density;

  MemoryInfo

    *pixel_info;

  RsvgDimensionData

    dimension_info;

  unsigned char

    *p,

    *pixels;

#else

  GdkPixbuf

    *pixel_buffer;

  const guchar

    *p;

#endif

  GError

    *error;

  Image

    *next;

  MagickBooleanType

    status;

  PixelInfo

    fill_color;

  Quantum

    *q;

  RsvgHandle

    *svg_handle;

  ssize_t

    n,

    x,

    y;

  unsigned char

    *buffer;

  buffer=(unsigned char *) AcquireQuantumMemory(MagickMaxBufferExtent,

    sizeof(*buffer));

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

    ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");

  {

#if LIBRSVG_CHECK_VERSION(2,40,3)

    const char *option = GetImageOption(image_info,"svg:parse-huge");

    if (option == (char *) NULL)

      option=GetImageOption(image_info,"svg:xml-parse-huge");  /* deprecated */

    if ((option != (char *) NULL) && (IsStringTrue(option) != MagickFalse))

      svg_handle=rsvg_handle_new_with_flags(RSVG_HANDLE_FLAG_UNLIMITED);

    else

#endif

      svg_handle=rsvg_handle_new();

  }

  if (svg_handle == (RsvgHandle *) NULL)

    {

      buffer=(unsigned char *) RelinquishMagickMemory(buffer);

      ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");

    }

  rsvg_handle_set_base_uri(svg_handle,image_info->filename);

  if ((fabs(image->resolution.x) > MagickEpsilon) &&

      (fabs(image->resolution.y) > MagickEpsilon))

    rsvg_handle_set_dpi_x_y(svg_handle,image->resolution.x,image->resolution.y);

  while ((n=ReadBlob(image,MagickMaxBufferExtent-1,buffer)) != 0)

  {

    buffer[n]='\0';

    error=(GError *) NULL;

    (void) rsvg_handle_write(svg_handle,buffer,(gsize) n,&error);

    if (error != (GError *) NULL)

      {

        g_error_free(error);

        break;

      }

  }

  buffer=(unsigned char *) RelinquishMagickMemory(buffer);

  error=(GError *) NULL;

  rsvg_handle_close(svg_handle,&error);

  if (error != (GError *) NULL)

    {

      g_error_free(error);

      g_object_unref(svg_handle);

      ThrowReaderException(CorruptImageError,"UnableToReadImageData");

    }

#if defined(MAGICKCORE_CAIRO_DELEGATE)

  apply_density=MagickTrue;

  rsvg_handle_get_dimensions(svg_handle,&dimension_info);

  if ((image->resolution.x > 0.0) && (image->resolution.y > 0.0))

    {

      RsvgDimensionData

        dpi_dimension_info;

      /*

        We should not apply the density when the internal 'factor' is 'i'.

        This can be checked by using the trick below.

      */

      rsvg_handle_set_dpi_x_y(svg_handle,image->resolution.x*256,

        image->resolution.y*256);

      rsvg_handle_get_dimensions(svg_handle,&dpi_dimension_info);

      if ((fabs((double) dpi_dimension_info.width-dimension_info.width) >= MagickEpsilon) ||

          (fabs((double) dpi_dimension_info.height-dimension_info.height) >= MagickEpsilon))

        apply_density=MagickFalse;

      rsvg_handle_set_dpi_x_y(svg_handle,image->resolution.x,

        image->resolution.y);

    }

  if (image_info->size != (char *) NULL)

    {

      (void) GetGeometry(image_info->size,(ssize_t *) NULL,(ssize_t *) NULL,

        &image->columns,&image->rows);

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

        {

          image->resolution.x=DefaultSVGDensity*image->columns/

            dimension_info.width;

          image->resolution.y=DefaultSVGDensity*image->rows/

            dimension_info.height;

          if (fabs(image->resolution.x) < MagickEpsilon)

            image->resolution.x=image->resolution.y;

          else

            if (fabs(image->resolution.y) < MagickEpsilon)

              image->resolution.y=image->resolution.x;

            else

              image->resolution.x=image->resolution.y=MagickMin(

                image->resolution.x,image->resolution.y);

          apply_density=MagickTrue;

        }

    }

  if (apply_density != MagickFalse)

    {

      image->columns=(size_t) (image->resolution.x*dimension_info.width/

        DefaultSVGDensity);

      image->rows=(size_t) (image->resolution.y*dimension_info.height/

        DefaultSVGDensity);

    }

  else

    {

      image->columns=(size_t) dimension_info.width;

      image->rows=(size_t) dimension_info.height;

    }

  pixel_info=(MemoryInfo *) NULL;

#else

  pixel_buffer=rsvg_handle_get_pixbuf(svg_handle);

  rsvg_handle_free(svg_handle);

  image->columns=gdk_pixbuf_get_width(pixel_buffer);

  image->rows=gdk_pixbuf_get_height(pixel_buffer);

#endif

  image->alpha_trait=BlendPixelTrait;

  if (image_info->ping == MagickFalse)

    {

#if defined(MAGICKCORE_CAIRO_DELEGATE)

      size_t

        stride;

#endif

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

      if (status == MagickFalse)

        {

#if !defined(MAGICKCORE_CAIRO_DELEGATE)

          g_object_unref(G_OBJECT(pixel_buffer));

#endif

          g_object_unref(svg_handle);

          ThrowReaderException(MissingDelegateError,

            "NoDecodeDelegateForThisImageFormat");

        }

#if defined(MAGICKCORE_CAIRO_DELEGATE)

      stride=4*image->columns;

#if defined(MAGICKCORE_PANGOCAIRO_DELEGATE)

      stride=(size_t) cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32,

        (int) image->columns);

#endif

      pixel_info=AcquireVirtualMemory(stride,image->rows*sizeof(*pixels));

      if (pixel_info == (MemoryInfo *) NULL)

        {

          g_object_unref(svg_handle);

          ThrowReaderException(ResourceLimitError,

            "MemoryAllocationFailed");

        }

      pixels=(unsigned char *) GetVirtualMemoryBlob(pixel_info);

#endif

      (void) SetImageBackgroundColor(image,exception);

#if defined(MAGICKCORE_CAIRO_DELEGATE)

      cairo_surface=cairo_image_surface_create_for_data(pixels,

        CAIRO_FORMAT_ARGB32,(int) image->columns,(int) image->rows,(int)

        stride);

      if ((cairo_surface == (cairo_surface_t *) NULL) ||

          (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS))

        {

          if (cairo_surface != (cairo_surface_t *) NULL)

            cairo_surface_destroy(cairo_surface);

          pixel_info=RelinquishVirtualMemory(pixel_info);

          g_object_unref(svg_handle);

          ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");

        }

      cairo_image=cairo_create(cairo_surface);

      cairo_set_operator(cairo_image,CAIRO_OPERATOR_CLEAR);

      cairo_paint(cairo_image);

      cairo_set_operator(cairo_image,CAIRO_OPERATOR_OVER);

      if (apply_density != MagickFalse)

        cairo_scale(cairo_image,image->resolution.x/DefaultSVGDensity,

          image->resolution.y/DefaultSVGDensity);

      rsvg_handle_render_cairo(svg_handle,cairo_image);

      cairo_destroy(cairo_image);

      cairo_surface_destroy(cairo_surface);

      g_object_unref(svg_handle);

      p=pixels;

#else

      p=gdk_pixbuf_get_pixels(pixel_buffer);

#endif

      GetPixelInfo(image,&fill_color);

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

      {

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

        if (q == (Quantum *) NULL)

          break;

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

        {

#if defined(MAGICKCORE_CAIRO_DELEGATE)

          fill_color.blue=ScaleCharToQuantum(*p++);

          fill_color.green=ScaleCharToQuantum(*p++);

          fill_color.red=ScaleCharToQuantum(*p++);

#else

          fill_color.red=ScaleCharToQuantum(*p++);

          fill_color.green=ScaleCharToQuantum(*p++);

          fill_color.blue=ScaleCharToQuantum(*p++);

#endif

          fill_color.alpha=ScaleCharToQuantum(*p++);

#if defined(MAGICKCORE_CAIRO_DELEGATE)

          {

            double

              gamma;

            gamma=QuantumScale*fill_color.alpha;

            gamma=MagickSafeReciprocal(gamma);

            fill_color.blue*=gamma;

            fill_color.green*=gamma;

            fill_color.red*=gamma;

          }

#endif

          CompositePixelOver(image,&fill_color,fill_color.alpha,q,(double)

            GetPixelAlpha(image,q),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 defined(MAGICKCORE_CAIRO_DELEGATE)

  else

    g_object_unref(svg_handle);

  if (pixel_info != (MemoryInfo *) NULL)

    pixel_info=RelinquishVirtualMemory(pixel_info);

#else

  g_object_unref(G_OBJECT(pixel_buffer));

#endif

  (void) CloseBlob(image);

  for (next=GetFirstImageInList(image); next != (Image *) NULL; )

  {

    (void) CopyMagickString(next->filename,image->filename,MagickPathExtent);

    (void) CopyMagickString(next->magick,image->magick,MagickPathExtent);

    next=GetNextImageInList(next);

  }

  return(GetFirstImageInList(image));

}

#endif

#if defined(MAGICKCORE_XML_DELEGATE)

static SVGInfo *AcquireSVGInfo(void)

{

  SVGInfo

    *svg_info;

  svg_info=(SVGInfo *) AcquireMagickMemory(sizeof(*svg_info));

  if (svg_info == (SVGInfo *) NULL)

    return((SVGInfo *) NULL);

  (void) memset(svg_info,0,sizeof(*svg_info));

  svg_info->text=AcquireString("");

  svg_info->scale=(double *) AcquireCriticalMemory(sizeof(*svg_info->scale));

  GetAffineMatrix(&svg_info->affine);

  svg_info->scale[0]=ExpandAffine(&svg_info->affine);

  return(svg_info);

}

static SVGInfo *DestroySVGInfo(SVGInfo *svg_info)

{

  if (svg_info->size != (char *) NULL)

    svg_info->size=DestroyString(svg_info->size);

  if (svg_info->text != (char *) NULL)

    svg_info->text=DestroyString(svg_info->text);

  if (svg_info->scale != (double *) NULL)

    svg_info->scale=(double *) RelinquishMagickMemory(svg_info->scale);

  if (svg_info->title != (char *) NULL)

    svg_info->title=DestroyString(svg_info->title);

  if (svg_info->comment != (char *) NULL)

    svg_info->comment=DestroyString(svg_info->comment);

  if (svg_info->offset != (char *) NULL)

    svg_info->offset=DestroyString(svg_info->offset);

  if (svg_info->stop_color != (char *) NULL)

    svg_info->stop_color=DestroyString(svg_info->stop_color);

  if (svg_info->vertices != (char *) NULL)

    svg_info->vertices=DestroyString(svg_info->vertices);

  if (svg_info->url != (char *) NULL)

    svg_info->url=DestroyString(svg_info->url);

  return((SVGInfo *) RelinquishMagickMemory(svg_info));

}

static double GetUserSpaceCoordinateValue(const SVGInfo *svg_info,int type,

  const char *string)

{

  char

    *next_token,

    token[MagickPathExtent];

  const char

    *p;

  double

    value;

  if (IsEventLogging() != MagickFalse)

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

  assert(string != (const char *) NULL);

  p=(const char *) string;

  (void) GetNextToken(p,&p,MagickPathExtent,token);

  value=StringToDouble(token,&next_token);

  if (strchr(token,'%') != (char *) NULL)

    {

      double

        alpha,

        beta;

      if (type > 0)

        {

          if (svg_info->view_box.width < MagickEpsilon)

            return(0.0);

          return(svg_info->view_box.width*value/100.0);

        }

      if (type < 0)

        {

          if (svg_info->view_box.height < MagickEpsilon)

            return(0.0);

          return(svg_info->view_box.height*value/100.0);

        }

      alpha=value-svg_info->view_box.width;

      beta=value-svg_info->view_box.height;

      return(hypot(alpha,beta)/sqrt(2.0)/100.0);

    }

  (void) GetNextToken(p,&p,MagickPathExtent,token);

  if (LocaleNCompare(token,"cm",2) == 0)

    return(DefaultSVGDensity*svg_info->scale[0]/2.54*value);

  if (LocaleNCompare(token,"em",2) == 0)

    return(svg_info->pointsize*value);

  if (LocaleNCompare(token,"ex",2) == 0)

    return(svg_info->pointsize*value/2.0);

  if (LocaleNCompare(token,"in",2) == 0)

    return(DefaultSVGDensity*svg_info->scale[0]*value);

  if (LocaleNCompare(token,"mm",2) == 0)

    return(DefaultSVGDensity*svg_info->scale[0]/25.4*value);

  if (LocaleNCompare(token,"pc",2) == 0)

    return(DefaultSVGDensity*svg_info->scale[0]/6.0*value);

  if (LocaleNCompare(token,"pt",2) == 0)

    return(svg_info->scale[0]*value);

  if (LocaleNCompare(token,"px",2) == 0)

    return(value);

  return(value);

}

#if defined(__cplusplus) || defined(c_plusplus)

extern "C" {

#endif

static void SVGStripString(const MagickBooleanType trim,char *message)

{

  char

    *p,

    *q;

  size_t

    length;

  assert(message != (char *) NULL);

  if (*message == '\0')

    return;

  /*

    Remove comment.

  */

  q=message;

  for (p=message; *p != '\0'; p++)

  {

    if ((*p == '/') && (*(p+1) == '*'))

      {

        for ( ; *p != '\0'; p++)

          if ((*p == '*') && (*(p+1) == '/'))

            {

              p+=(ptrdiff_t) 2;

              break;

            }

        if (*p == '\0')

          break;

      }

    *q++=(*p);

  }

  *q='\0';

  length=strlen(message);

  if ((trim != MagickFalse) && (length != 0))

    {

      /*

        Remove whitespace.

      */

      p=message;

      while (isspace((int) ((unsigned char) *p)) != 0)

        p++;

      if ((*p == '\'') || (*p == '"'))

        p++;

      q=message+length-1;

      while ((isspace((int) ((unsigned char) *q)) != 0) && (q > p))

        q--;

      if (q > p)

        if ((*q == '\'') || (*q == '"'))

          q--;

      (void) memmove(message,p,(size_t) (q-p+1));

      message[q-p+1]='\0';

    }

  /*

    Convert newlines to a space.

  */

  for (p=message; *p != '\0'; p++)

    if ((*p == '\n') || (*p == '\r'))

      *p=' ';

}

static char **SVGKeyValuePairs(SVGInfo *svg_info,const int key_sentinel,

  const int value_sentinel,const char *text,size_t *number_tokens)

{

  char

    **tokens;

  const char

    *p,

    *q;

  size_t

    extent;

  ssize_t

    i;

  *number_tokens=0;

  if (text == (const char *) NULL)

    return((char **) NULL);

  extent=8;

  tokens=(char **) AcquireQuantumMemory(extent+2UL,sizeof(*tokens));

  if (tokens == (char **) NULL)

    {

      (void) ThrowMagickException(svg_info->exception,GetMagickModule(),

        ResourceLimitError,"MemoryAllocationFailed","`%s'",text);

      return((char **) NULL);

    }

  /*

    Convert string to an ASCII list.

  */

  i=0;

  p=text;

  for (q=p; *q != '\0'; q++)

  {

    if ((*q != key_sentinel) && (*q != value_sentinel) && (*q != '\0'))

      continue;

    if (i == (ssize_t) extent)

      {

        extent<<=1;

        tokens=(char **) ResizeQuantumMemory(tokens,extent+2,sizeof(*tokens));

        if (tokens == (char **) NULL)

          {

            (void) ThrowMagickException(svg_info->exception,GetMagickModule(),

              ResourceLimitError,"MemoryAllocationFailed","`%s'",text);

            return((char **) NULL);

          }

      }

    tokens[i]=(char *) AcquireMagickMemory((size_t) (q-p+2));

    if (tokens[i] == (char *) NULL)

      {

        ssize_t

          j;

        (void) ThrowMagickException(svg_info->exception,GetMagickModule(),

          ResourceLimitError,"MemoryAllocationFailed","`%s'",text);

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

          tokens[j]=DestroyString(tokens[j]);

        tokens=(char **) RelinquishMagickMemory(tokens);

        return(tokens);

      }

    (void) CopyMagickString(tokens[i],p,(size_t) (q-p+1));

    SVGStripString(MagickTrue,tokens[i]);

    i++;

    p=q+1;

  }

  tokens[i]=(char *) AcquireMagickMemory((size_t) (q-p+2));

  if (tokens[i] == (char *) NULL)

    (void) ThrowMagickException(svg_info->exception,GetMagickModule(),

      ResourceLimitError,"MemoryAllocationFailed","`%s'",text);

  else

    {

      (void) CopyMagickString(tokens[i],p,(size_t) (q-p+1));

      SVGStripString(MagickTrue,tokens[i++]);

    }

  tokens[i]=(char *) NULL;

  *number_tokens=(size_t) i;

  return(tokens);

}

static inline char *SVGEscapeString(const char* value)

{

  char

    *escaped_value,

    *p;

  escaped_value=EscapeString(value,'\"');

  for (p=escaped_value; *p != '\0'; p++)

    if ((*p == '\n') || (*p == '\r'))

      *p=' ';

  return(escaped_value);

}

static void SVGProcessStyleElement(SVGInfo *svg_info,const xmlChar *name,

  const char *style)

{

  char

    background[MagickPathExtent],

    *color,

    *keyword,

    **tokens,

    *units;

  size_t

    number_tokens;

  ssize_t

    i;

  (void) LogMagickEvent(CoderEvent,GetMagickModule(),"  ");

  tokens=SVGKeyValuePairs(svg_info,':',';',style,&number_tokens);

  if (tokens == (char **) NULL)

    return;

  for (i=0; i < ((ssize_t) number_tokens-1); i+=2)

  {

    keyword=(char *) tokens[i];

    if (LocaleCompare(keyword,"font-size") != 0)

      continue;

    svg_info->pointsize=GetUserSpaceCoordinateValue(svg_info,0,

      (char *) tokens[i+1]);

    (void) FormatLocaleFile(svg_info->file,"font-size %g\n",

      svg_info->pointsize);

  }

  color=AcquireString("none");

  units=AcquireString("userSpaceOnUse");

  for (i=0; i < ((ssize_t) number_tokens-1); i+=2)

  {

    char

      *value;

    keyword=(char *) tokens[i];

    value=SVGEscapeString((const char *) tokens[i+1]);

    (void) LogMagickEvent(CoderEvent,GetMagickModule(),"    %s: %s",keyword,

      value);

    switch (*keyword)

    {

      case 'B':

      case 'b':

      {

        if (LocaleCompare((const char *) name,"background") == 0)

          {

            if (LocaleCompare((const char *) name,"svg") == 0)

              (void) CopyMagickString(background,value,MagickPathExtent);

            break;

          }

        break;

      }

      case 'C':

      case 'c':

      {

         if (LocaleCompare(keyword,"clip-path") == 0)

           {

             (void) FormatLocaleFile(svg_info->file,"clip-path \"%s\"\n",value);

             break;

           }

        if (LocaleCompare(keyword,"clip-rule") == 0)

          {

            (void) FormatLocaleFile(svg_info->file,"clip-rule \"%s\"\n",value);

            break;

          }

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

           {

             (void) CloneString(&units,value);

             (void) FormatLocaleFile(svg_info->file,"clip-units \"%s\"\n",

               value);

             break;

           }

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

          {

            (void) CloneString(&color,value);

            (void) FormatLocaleFile(svg_info->file,"currentColor \"%s\"\n",

              color);

            break;

          }

        break;

      }

      case 'F':

      case 'f':

      {

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

          {

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

               {

                 (void) FormatLocaleFile(svg_info->file,"fill \"%s\"\n",color);

                 break;

               }

            if (LocaleCompare(value,"#000000ff") == 0)

              (void) FormatLocaleFile(svg_info->file,"fill '#000000'\n");

            else

              (void) FormatLocaleFile(svg_info->file,"fill \"%s\"\n",value);

            break;

          }

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

          {

            (void) FormatLocaleFile(svg_info->file,"fill \"%s\"\n",value);

            break;

          }

        if (LocaleCompare(keyword,"fill-rule") == 0)

          {

            (void) FormatLocaleFile(svg_info->file,"fill-rule \"%s\"\n",value);

            break;

          }

        if (LocaleCompare(keyword,"fill-opacity") == 0)

          {

            (void) FormatLocaleFile(svg_info->file,"fill-opacity \"%s\"\n",

              value);

            break;

          }

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

          {

            char

              font_family[MagickPathExtent],

              font_size[MagickPathExtent],

              font_style[MagickPathExtent];

            if (MagickSscanf(value,"%2048s %2048s %2048s",font_style,font_size,

                  font_family) != 3)

              break;

            if (GetUserSpaceCoordinateValue(svg_info,0,font_style) == 0)

              (void) FormatLocaleFile(svg_info->file,"font-style \"%s\"\n",

                style);

            else

              if (MagickSscanf(value,"%2048s %2048s",font_size,font_family) != 2)

                break;

            (void) FormatLocaleFile(svg_info->file,"font-size \"%s\"\n",

              font_size);

            (void) FormatLocaleFile(svg_info->file,"font-family \"%s\"\n",

              font_family);

            break;

          }

        if (LocaleCompare(keyword,"font-family") == 0)

          {

            (void) FormatLocaleFile(svg_info->file,"font-family \"%s\"\n",

              value);

            break;

          }

        if (LocaleCompare(keyword,"font-stretch") == 0)

          {

            (void) FormatLocaleFile(svg_info->file,"font-stretch \"%s\"\n",

              value);

            break;

          }

        if (LocaleCompare(keyword,"font-style") == 0)

          {

            (void) FormatLocaleFile(svg_info->file,"font-style \"%s\"\n",value);

            break;

          }

        if (LocaleCompare(keyword,"font-size") == 0)

          {

            svg_info->pointsize=GetUserSpaceCoordinateValue(svg_info,0,value);

            (void) FormatLocaleFile(svg_info->file,"font-size %g\n",

              svg_info->pointsize);

            break;

          }

        if (LocaleCompare(keyword,"font-weight") == 0)

          {

            (void) FormatLocaleFile(svg_info->file,"font-weight \"%s\"\n",

              value);

            break;

          }

        break;

      }

      case 'K':

      case 'k':

      {

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

          {

            (void) FormatLocaleFile(svg_info->file,"kerning \"%s\"\n",value);

            break;

          }

        break;

      }

      case 'L':

      case 'l':

      {

        if (LocaleCompare(keyword,"letter-spacing") == 0)

          {

            (void) FormatLocaleFile(svg_info->file,"letter-spacing \"%s\"\n",

              value);

            break;

          }

        break;

      }

      case 'M':

      case 'm':

      {

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

          {

            (void) FormatLocaleFile(svg_info->file,"mask \"%s\"\n",value);

            break;

          }

        break;

      }

      case 'O':

      case 'o':

      {

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

          {

            (void) FormatLocaleFile(svg_info->file,"offset %g\n",

              GetUserSpaceCoordinateValue(svg_info,1,value));

            break;

          }

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

          {