upmf.c

/**
  @file upmf.c
  
  @brief Functions for manipulating EMF+ files and structures.

  EMF+ is much more object based than is EMF or WMF, so the U_PMR_*_set and most U_PMF_*_set functions
  return a pointer to a PseudoObject.  PseudoObjects are structs that contain a data field to hold the
  object in EMF+ file byte order, size information, and some type information.  This is sufficient to allow
  complex records to be built up from the various sorts of nested objects which they normally contain.
  If something goes wrong a NULL pointer is returned and recsize is set to 0.
  
  EMF+ does not use a separate set of endian functions, _get and _set routines convert from/to
  the EMF+ file byte order on the fly.
    
        WARNING:  Microsoft's EMF+ documentation is little-endian for everything EXCEPT
        bitfields,  which are big-endian.   See EMF+ manual section 1.3.2              
        That documentation also uses 0 as the MOST significant bit, N-1 as the least.  
        This code is little-endian throughout, and 0 is the LEAST significant bit      
  
*/

/*
File:      upmf.c
Version:   0.0.13
Date:      21-MAR-2019
Author:    David Mathog, Biology Division, Caltech
email:     mathog@caltech.edu
Copyright: 2019 David Mathog and California Institute of Technology (Caltech)
*/

#ifdef __cplusplus
extern "C" {
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iconv.h>
#include <wchar.h>
#include <errno.h>
#include <string.h>
#include <limits.h> // for INT_MAX, INT_MIN
#include <math.h>   // for sin, cos, tan2, use U_ROUND() instead of roundf() 
#include <stddef.h> /* for offsetof() macro */
#if 0
#include <windef.h>    //Not actually used, looking for collisions
#include <winnt.h>    //Not actually used, looking for collisions
#include <wingdi.h>   //Not actually used, looking for collisions
#endif
#include "upmf.h"         // includes uemf.h
#include "uemf_endian.h"  // for U_swap* functions

//! \cond

/// things Doxygen should not process
/* remove this after debugging is completed */
void dumphex(uint8_t *buf,unsigned int num){
   for(; num; num--,buf++){
      printf("%2.2X",*buf);
   }
}


/* Prototypes for functions used here and defined in uemf_endian.c, but which are not supposed
to be used in end user code. */

void U_swap2(void *ul, unsigned int count);
void U_swap4(void *ul, unsigned int count);
//! \endcond

/**
    \brief  Utility function for writing one or more EMF+ records in a PseudoObject to the EMF output file
    \return 1 on success, 0 on error.
    \param  po          U_PSEUDO_OBJ to write, it is deleted after it is written
    \param  sum         U_PSEUDO_OBJ to use for scratch space
    \param  et          EMFTRACK used to write records to EMF file
*/
int U_PMR_write(U_PSEUDO_OBJ *po, U_PSEUDO_OBJ *sum, EMFTRACK *et){
   char *rec;
   int status = 0;
   sum->Used = 0;                                          /* clean it out, retaining allocated memory         */
   sum       = U_PO_append(sum, "EMF+", 4);                /* indicates that this comment holds an EMF+ record */
   if(!sum)goto end;
   sum       = U_PO_append(sum,  po->Data, po->Used);      /* the EMF+ record itself                           */
   if(!sum)goto end;
   U_PO_free(&po);                                         /* delete the PseudoObject                          */
   rec       = U_EMRCOMMENT_set(sum->Used, sum->Data);     /* stuff it into the EMF comment                    */
   if(!emf_append((PU_ENHMETARECORD)rec, et, 1))goto end;  /* write it to the EMF file, delete the record, check status */
   status = 1;
end:
   return(status);
}

/**
    \brief  Utility function to draw a line.
    \return 1 on success, 0 on error.
    \param  PenID       Index of U_PMF_PEN object to use in the EMF+ object table (0-63, inclusive)
    \param  PathID      Index of U_PMF_PATH object to use in the EMF+ object table (0-63, inclusive)
    \param  Start       U_PMF_POINTF coordinates of start of line.
    \param  End         U_PMF_POINTF coordinates of end of line.
    \param  Dashed      Set if the line is dashed, clear if it is not.
    \param  sum         PseudoObject used for scratch space
    \param  et          EMFTRACK used to write records to EMF file
   
*/
int U_PMR_drawline(uint32_t PenID, uint32_t PathID, U_PMF_POINTF Start, U_PMF_POINTF End, int Dashed, U_PSEUDO_OBJ *sum, EMFTRACK *et){
   U_DPSEUDO_OBJ *dpath;
   U_PSEUDO_OBJ *poPath;
   U_PSEUDO_OBJ *po;
   int           status=0;
   int           PTP_value = ( Dashed ? U_PTP_DashMode : U_PTP_None);
   dpath =  U_PATH_create(0, NULL, 0, 0); /* create an empty path*/
   if(dpath){
      if(U_PATH_moveto(dpath, Start, PTP_value) && U_PATH_lineto(dpath, End, PTP_value)){
         poPath = U_PMF_PATH_set2(U_PMF_GRAPHICSVERSIONOBJ_set(2), dpath);
         if(poPath){
            po = U_PMR_OBJECT_PO_set(PathID, poPath);
            U_PO_free(&poPath);
            if(po){
               U_PMR_write(po, sum, et);
               po = U_PMR_DRAWPATH_set(PathID, PenID);
               if(po){
                  U_PMR_write(po, sum, et);
                  status = 1;
               }
            }
         }
      }
      U_DPO_free(&dpath);
   }
   return(status);
}

/**
    \brief  Utility function for drawing strings onto the baseline in one call.
    \return 1 on success, 0 on error.
    \param  string      Text to draw in UTF-8 format
    \param  Vpos        StringAlignment Enumeration.  Always drawn on baseline, but using one of these three modes.
    \param  FontID      Index of U_PMF_FONT object to use in the EMF+ object table (0-63, inclusive)
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    \param  FormatID    index of U_PMF_STRINGFORMAT object to use in the EMF+ Object Table.
    \param  Sfs         StringFormat structure. Ignored values: StringAlignment, LineAlign, Flags
    \param  FontName    Name of font to draw with
    \param  Height      Height of font in pixels (positive)
    \param  fip         U_FontInfoParams (ascent, descent, and so forth)
    \param  FontFlags   FontStyle Flags
    \param  x           X position in pixels of left side of EM box of first character
    \param  y           Y position in pixels of baseline of first character
    \param  sum         PseudoObject used for scratch space
    \param  et          EMFTRACK used to write records to EMF file
   
    EMF+ manual 2.3.4.14, Microsoft name: EmfPlusDrawString Record, Index 0x1C
    
    For most fonts Ascent and Descent are used to adjust the bounding box to properly position the
    baseline.  Some fonts, like Verdana, are strange and they position the baseline on the bottom of
    the bounding box if that box has the same height as the font.  For those fonts specify 0.0 for
    both Ascent and Descent.
*/
int U_PMR_drawstring( const char *string, int Vpos, uint32_t FontID, const U_PSEUDO_OBJ *BrushID, uint32_t FormatID,
      U_PMF_STRINGFORMAT  Sfs, const char *FontName, U_FLOAT Height, U_FontInfoParams *fip, uint32_t FontFlags,
      U_FLOAT x, U_FLOAT y, U_PSEUDO_OBJ *sum, EMFTRACK *et){
   U_PSEUDO_OBJ  *po;
   U_PSEUDO_OBJ  *poSF;
   U_PSEUDO_OBJ  *poFont;
   U_PSEUDO_OBJ  *poRect;
   U_FLOAT        rx,ry,rw,rh,rd;
   uint16_t      *UFontName;
   uint16_t      *Text16;
   int            slen;
   int            status = 0;
   double         aval, dval;
   
   Sfs.Flags           = U_SF_NoFitBlackBox + U_SF_NoClip;
   
   if(Vpos < U_SA_Near || Vpos > U_SA_Far)return(0);
   Sfs.StringAlignment = U_SA_Near; //  Horizontal
   Sfs.LineAlign       = Vpos; //  Vertical

   UFontName = U_Utf8ToUtf16le(FontName, 0, NULL);
   slen = strlen(FontName);
   poFont = U_PMF_FONT_set(U_PMF_GRAPHICSVERSIONOBJ_set(2), Height, U_UT_World, FontFlags, slen, UFontName);
   if(poFont){
      po = U_PMR_OBJECT_PO_set(FontID, poFont); /* font to use */
      if(po){
         U_PMR_write(po, sum, et);
         
         poSF = U_PMF_STRINGFORMAT_set(&Sfs, NULL);
         if(poSF){
            po = U_PMR_OBJECT_PO_set(FormatID, poSF);
            U_PO_free(&poSF);
            if(po){
               U_PMR_write(po, sum, et);

               rw = 4*Height*slen; /* This could probably be any value */
               rh = Height;
               rx = x;
               if(fip->LineGap > -fip->Descent){ aval = fip->yMax;   } // sylfaen, palatino
               else {                            aval = fip->Ascent; } // others
               if(fip->LineGap && (fip->LineGap < -fip->Descent)){ dval =  ((double) (fip->Descent - fip->LineGap)) / ((double) fip->EmSize); } //shruti and some others
               else {                                              dval =  ((double)  fip->Descent                ) / ((double) fip->EmSize); }
               switch(Vpos){
                  case U_SA_Near:  
                     rd = Height * aval / ((double) fip->EmSize);
                     break;
                  case U_SA_Center:
                     rd = 0.5 * (  Height * aval / ((double) fip->EmSize) +  Height * ( 1.0 +  dval));
                     break;
                  case U_SA_Far:
                     rd = Height * ( 1.0 +  dval);
                     break;
               }
               ry = y - rd;   /* draw from upper left corner, which is shifted to put baseline on y */
               poRect = U_PMF_RECTF4_set(rx, ry, rw, rh); 
#if 0
(void) U_PMR_drawline(OBJ_PEN_BLACK_1,OBJ_PATH_1, (U_PMF_POINTF){x-100, ry}, (U_PMF_POINTF){x+100, ry},  0, sum, et);
(void) U_PMR_drawline(OBJ_PEN_BLACK_1,OBJ_PATH_1, (U_PMF_POINTF){x-100, ry+rh}, (U_PMF_POINTF){x+100, ry+rh},  0, sum, et);
(void) U_PMR_drawline(OBJ_PEN_BLACK_1,OBJ_PATH_1, (U_PMF_POINTF){x-100, ry}, (U_PMF_POINTF){x-100, ry + Height * (double) fip->Ascent / ((double) fip->EmSize)},  0, sum, et);
(void) U_PMR_drawline(OBJ_PEN_BLACK_1,OBJ_PATH_1, (U_PMF_POINTF){x- 90, ry}, (U_PMF_POINTF){x- 90, ry - Height * (double) fip->Descent / ((double) fip->EmSize)},  0, sum, et);
(void) U_PMR_drawline(OBJ_PEN_BLACK_1,OBJ_PATH_1, (U_PMF_POINTF){x- 80, ry}, (U_PMF_POINTF){x- 80, ry + Height * (double) fip->yMax / ((double) fip->EmSize)},  0, sum, et);
(void) U_PMR_drawline(OBJ_PEN_BLACK_1,OBJ_PATH_1, (U_PMF_POINTF){x- 70, ry}, (U_PMF_POINTF){x- 70, ry - Height * (double) fip->yMin / ((double) fip->EmSize)},  0, sum, et);
(void) U_PMR_drawline(OBJ_PEN_BLACK_1,OBJ_PATH_1, (U_PMF_POINTF){x- 60, ry}, (U_PMF_POINTF){x- 60, ry + Height * (double) fip->LineGap / ((double) fip->EmSize)},  0, sum, et);
(void) U_PMR_drawline(OBJ_PEN_BLACK_1,OBJ_PATH_1, (U_PMF_POINTF){x- 50, ry}, (U_PMF_POINTF){x- 50, ry + Height * ( 1.0 -  (((double) (fip->LineGap - fip->Descent)) / ((double) fip->EmSize)) )},  0, sum, et);
#endif

               Text16 = U_Utf8ToUtf16le(string, 0, NULL);
               slen = strlen(string);
               po = U_PMR_DRAWSTRING_set(FontID, BrushID, FormatID, slen, poRect, Text16);
               if(po){
                  U_PMR_write(po, sum, et);
                  status = 1;                                             /* Success!!!                                       */
               }
               U_PO_free(&poRect);
               free(Text16);
            }
         }
      }
      U_PO_free(&poFont);
   }
   free(UFontName);
   return(status);
}

/**
    \brief Allocate and construct an array of U_POINT16 objects from a set of U_PMF_POINTF objects, endianness in and out is LE
    \returns pointer to an array of U_POINT16 structures.
    \param points  pointer to the source U_POINT structures
    \param count   number of members in points

    If a coordinate is out of range it saturates at boundary.
*/
U_PMF_POINT *POINTF_To_POINT16_LE(U_PMF_POINTF *points, int count){
   U_PMF_POINT *newpts;
   U_PMF_POINTF ptfl;
   int i;
   newpts = (U_PMF_POINT *) malloc(count * sizeof(U_PMF_POINT));

   for(i=0; i<count; i++){
      memcpy(&ptfl, &(points[i]), 8);
      if(U_BYTE_SWAP){  U_swap4(&ptfl,2); } /* on BE platforms swap going in and coming out */
      newpts[i].X = U_MNMX(ptfl.X, INT16_MIN, INT16_MAX);
      newpts[i].Y = U_MNMX(ptfl.Y, INT16_MIN, INT16_MAX);
      if(U_BYTE_SWAP){  U_swap2(&(newpts[i]),2); }
   }
   return(newpts);
}

/**
    \brief Look up the name of the EMR+ record by type.  Returns U_EMR_INVALID if out of range.
        
    \return name of the PMR record, "U_EMR_INVALID" if out of range.
    \param idx  PMR record type WITHOUT the U_PMR_RECFLAG bit. 
    
*/
char *U_pmr_names(unsigned int idx){
   if(idx<U_PMR_MIN || idx > U_PMR_MAX){ idx = 0; }
   static char *U_PMR_NAMES[U_PMR_MAX+1]={
      "U_PMR_INVALID",          
      "U_PMR_Header",
      "U_PMR_EndOfFile",
      "U_PMR_Comment",
      "U_PMR_GetDC",
      "U_PMR_MultiFormatStart",
      "U_PMR_MultiFormatSection",
      "U_PMR_MultiFormatEnd",
      "U_PMR_Object",
      "U_PMR_Clear",
      "U_PMR_FillRects",
      "U_PMR_DrawRects",
      "U_PMR_FillPolygon",
      "U_PMR_DrawLines",
      "U_PMR_FillEllipse",
      "U_PMR_DrawEllipse",
      "U_PMR_FillPie",
      "U_PMR_DrawPie",
      "U_PMR_DrawArc",
      "U_PMR_FillRegion",
      "U_PMR_FillPath",
      "U_PMR_DrawPath",
      "U_PMR_FillClosedCurve",
      "U_PMR_DrawClosedCurve",
      "U_PMR_DrawCurve",
      "U_PMR_DrawBeziers",
      "U_PMR_DrawImage",
      "U_PMR_DrawImagePoints",
      "U_PMR_DrawString",
      "U_PMR_SetRenderingOrigin",
      "U_PMR_SetAntiAliasMode",
      "U_PMR_SetTextRenderingHint",
      "U_PMR_SetTextContrast",
      "U_PMR_SetInterpolationMode",
      "U_PMR_SetPixelOffsetMode",
      "U_PMR_SetCompositingMode",
      "U_PMR_SetCompositingQuality",
      "U_PMR_Save",
      "U_PMR_Restore",
      "U_PMR_BeginContainer",
      "U_PMR_BeginContainerNoParams",
      "U_PMR_EndContainer",
      "U_PMR_SetWorldTransform",
      "U_PMR_ResetWorldTransform",
      "U_PMR_MultiplyWorldTransform",
      "U_PMR_TranslateWorldTransform",
      "U_PMR_ScaleWorldTransform",
      "U_PMR_RotateWorldTransform",
      "U_PMR_SetPageTransform",
      "U_PMR_ResetClip",
      "U_PMR_SetClipRect",
      "U_PMR_SetClipPath",
      "U_PMR_SetClipRegion",
      "U_PMR_OffsetClip",
      "U_PMR_DrawDriverstring",
      "U_PMR_StrokeFillPath",
      "U_PMR_SerializableObject",
      "U_PMR_SetTSGraphics",
      "U_PMR_SetTSClip"
   };
   return(U_PMR_NAMES[idx]);
}

/**
    \brief Convert from PseudoObject OID to ObjectType enumeration.
    \returns OT value on success, 0 if no match
    \param OID   PseudoObject OID (based on EMF+ manual chapter number. )

    Only OTs that may be stored in the EMF+ object table are supported.
*/

int U_OID_To_OT(uint32_t OID){
   int otype;
   if(     OID==U_PMF_BRUSH_OID          ){ otype = U_OT_Brush;           }                    
   else if(OID==U_PMF_PEN_OID            ){ otype = U_OT_Pen;             }         
   else if(OID==U_PMF_PATH_OID           ){ otype = U_OT_Path;            }               
   else if(OID==U_PMF_REGION_OID         ){ otype = U_OT_Region;          }               
   else if(OID==U_PMF_IMAGE_OID          ){ otype = U_OT_Image;           }               
   else if(OID==U_PMF_FONT_OID           ){ otype = U_OT_Font;            }               
   else if(OID==U_PMF_STRINGFORMAT_OID   ){ otype = U_OT_StringFormat;    }               
   else if(OID==U_PMF_IMAGEATTRIBUTES_OID){ otype = U_OT_ImageAttributes; }               
   else if(OID==U_PMF_CUSTOMLINECAP_OID  ){ otype = U_OT_CustomLineCap;   } 
   else {                                   otype = U_OT_Invalid;         }          
   return(otype);
}

/**
    \brief Convert from PseudoObject OID to BrushType enumeration.
    \returns BT value on success, -1 if no match
    \param OID   PseudoObject OID (based on EMF+ manual chapter number. )

    Only OIDs that map to BT's are supported.
*/

int U_OID_To_BT(uint32_t OID){
   int otype;
   if(     OID==U_PMF_HATCHBRUSHDATA_OID          ){ otype = U_BT_HatchFill;      }                    
   else if(OID==U_PMF_LINEARGRADIENTBRUSHDATA_OID ){ otype = U_BT_LinearGradient; }               
   else if(OID==U_PMF_PATHGRADIENTBRUSHDATA_OID   ){ otype = U_BT_PathGradient;   }               
   else if(OID==U_PMF_SOLIDBRUSHDATA_OID          ){ otype = U_BT_SolidColor;     }               
   else if(OID==U_PMF_TEXTUREBRUSHDATA_OID        ){ otype = U_BT_TextureFill;    }               
   else {                                            otype = -1;                  }          
   return(otype);
}

/**
    \brief Convert from PseudoObject OID to CustomLineCapDataType Enumeration.
    \returns BT value on success, -1 if no match
    \param OID   PseudoObject OID (based on EMF+ manual chapter number. )

    Only OIDs that map to CLCDT's are supported.
*/

int U_OID_To_CLCDT(uint32_t OID){
   int otype;
   if(     OID==U_PMF_CUSTOMLINECAPDATA_OID       ){ otype = U_CLCDT_Default;         }                    
   else if(OID==U_PMF_CUSTOMLINECAPARROWDATA_OID ){  otype = U_CLCDT_AdjustableArrow; }               
   else {                                            otype = -1;                      }          
   return(otype);
}

/**
    \brief Convert from PseudoObject OID to ImageDataType Enumeration.
    \returns BT value on success, -1 if no match
    \param OID   PseudoObject OID (based on EMF+ manual chapter number. )

    Only OIDs that map to IDT's are supported.
*/

int U_OID_To_IDT(uint32_t OID){
   int otype;
   if(     OID==U_PMF_BITMAP_OID   ){ otype = U_IDT_Bitmap;   }                    
   else if(OID==U_PMF_METAFILE_OID ){ otype = U_IDT_Metafile; }               
   else {                             otype = -1;             }          
   return(otype);
}

/**
    \brief Convert from PseudoObject OID to RegionNodeDataType Enumeration.
    \returns BT value on success, -1 if no match
    \param OID   PseudoObject OID (based on EMF+ manual chapter number. )

    Only OIDs that map to RNDT's are supported.
*/

int U_OID_To_RNDT(uint32_t OID){
   int otype;
   if(     OID==U_PMF_REGIONNODECHILDNODES_OID   ){ otype = U_RNDT_Kids; }  /* there are 5 types, which must be specified separately */         
   else if(OID==U_PMF_RECTF_OID ){                  otype = U_RNDT_Rect; }               
   else if(OID==U_PMF_REGIONNODEPATH_OID ){         otype = U_RNDT_Path; }               
   else {                                           otype = -1;          }          
   return(otype);
}

/**
    \brief Append data to an U_OBJ_ACCUM structure.
    \param oa    pointer to the U_OBJ_ACCUM structure
    \param data  data to add
    \param size  bytes in data
    \param Type  object type
    \param Id    Object ID
    \returns 0 on success, !0 on error.  -1 on Type change, -2 on Id change
    
    Safe to test for Id, Type changes by calling with size=0.
*/
int U_OA_append(U_OBJ_ACCUM *oa, const char *data, int size, int Type, int Id){
   int tail;
   if(!oa)return(2);
   if(oa->used){
      if(oa->Type != Type)return(-1);
      if(oa->Id   != Id)return(-2);
   }
   tail = oa->used;
   if(oa->used + size >= oa->space){
      oa->space += size;
      char *newaccum = (char *) realloc(oa->accum, oa->space);
      if(!newaccum){
         oa->space -= size; /* put it back the way it was */
         return(1);
      }
      oa->accum = newaccum;
   }
   memcpy(oa->accum + tail,data,size);
   oa->used += size;
   oa->Type  = Type;
   oa->Id    = Id;
   return(0);
}


/**
    \brief Clear an U_OBJ_ACCUM structure.  Accumulated storage is retained.
    \param oa    pointer to the U_OBJ_ACCUM structure
    \returns 0 on success, !0 on error.
*/
int U_OA_clear(U_OBJ_ACCUM *oa){
   if(!oa)return(2);
   oa->used=0;
   /* Type and Id may be ignored as they are reset on the first append */
   return(0);
}

/**
    \brief Release an U_OBJ_ACCUM structure.  Accumulated storage is free'd.
    \param oa    pointer to the U_OBJ_ACCUM structure
    \returns 0 on success, !0 on error.
*/
int U_OA_release(U_OBJ_ACCUM *oa){
   if(!oa)return(2);
   oa->used=0;
   oa->space = 0;
   if(oa->accum)free(oa->accum);
   oa->accum=NULL;
   return(0);
}

/**
    \brief Create and set an U_PSEUDO_OBJ
    \returns pointer to the U_PSEUDO_OBJ, NULL on error
    \param Data  Data to copy into the PseudoObject's data. If NULL, space is allocated, but is cleared instead of filled.
    \param Size  Number of bytes to allocate for Data (may be >Use if padding is present) 
    \param Use   Number of data bytes in Data (whether or not Data is actually copied) 
    \param Type  Type numbers are from manual section: 1.2.3.47 -> 0x01020347 
    
    If Data is NULL and Size is 0 an empty PseudoObject is created.  One byte of storage
       is allocated for Data, Size is set to 1, and Used to 0.

    If Data is NULL and Size is !0 a zero filled PseudoObject is created.

    If Data is !Null and Size is !0 a data filled PseudoObject is created.
*/
U_PSEUDO_OBJ *U_PO_create(char *Data, size_t Size, size_t Use, uint32_t Type){
   if(Use>Size)return(NULL);
   size_t tSize = (Size ? Size : 1);
   U_PSEUDO_OBJ *po = (U_PSEUDO_OBJ *)malloc(sizeof(U_PSEUDO_OBJ));
   if(po){
      po->Data = malloc(tSize);
      if(po->Data){
         po->Size = tSize;
         po->Used = Use;
         po->Type = Type;
         if(Data){ memcpy(po->Data, Data, Use);   } /* if Use < Size uninitialized bytes will be present! */
         else {    memset(po->Data, 0,    tSize); }
      }
      else {
         free(po);
         po=NULL;
      }
   }
   return(po);
}

/**
    \brief Append data to a U_PSEUDO_OBJ object and return it
    \returns pointer to the U_PSEUDO_OBJ object, NULL on error
    \param po    PseudoObject to append to.  Cannot be NULL.
    \param Data  Data to copy into the PseudoObject's data. If NULL, space is allocated (if necessary) and cleared instead of filled.
    \param Size  Number of data bytes in Data
*/
U_PSEUDO_OBJ *U_PO_append(U_PSEUDO_OBJ *po, const char *Data, size_t Size){
   /* po cannot be NULL,as in U_PO_po_append(), because there would be no way to determine the TYPE of the resulting PO */
   if(po){
      if(!po->Data || po->Used + Size > po->Size){
         po->Size = po->Used + Size;
         char *newData = realloc(po->Data, po->Size);
         if(!newData){
            po->Size -= Size; /* put it back the way it was*/
            po=NULL;          /* skip the rest of the actions, does not affect po in caller */
         }
         else {
            po->Data = newData;
         }
      }
      if(po){ /* po->Data ready to append new data */
         if(Data){ memcpy(po->Data + po->Used, Data, Size); }
         else {    memset(po->Data + po->Used, 0,    Size); }
         po->Used += Size;
      }
   }
   return(po);
}

/**
    \brief Append data to a U_PSEUDO_OBJ object and return it
    \returns pointer to the U_PSEUDO_OBJ object, NULL on error
    \param po     PseudoObject to append to.  May be NULL.
    \param Src    PseudoObject to append.
    \param StripE Set: leading Elements in Src->Data is not copied, Clear: it is copied.
*/
U_PSEUDO_OBJ *U_PO_po_append(U_PSEUDO_OBJ *po, U_PSEUDO_OBJ *Src, int StripE){
   if(!Src){ return(NULL); }
   if((StripE && (Src->Used == 4)) || !Src->Used){ return(po); } /* appending nothing is not an error */
   char   *Data = Src->Data;
   size_t  Size = Src->Used;  /* append only what is used */
   U_PSEUDO_OBJ *ipo = po;
   if(StripE){ Size -= 4; }
   if(!ipo){
      ipo = U_PO_create(NULL, 0, 0, Src->Type); /* create an empty pseudoobject */
   }
   if(ipo){
      if(!ipo->Data || ipo->Used + Size > ipo->Size){
         ipo->Size = ipo->Used + Size;
         char *newData = realloc(ipo->Data, ipo->Size);
         if(!newData){
            if(ipo != po)U_PO_free(&ipo);
         }
         else {
            ipo->Data = newData;
         }
      }
      if(ipo){
         if(Data){
            if(StripE){  memcpy(ipo->Data + ipo->Used, Data + 4, Size); } /* Size is already 4 less, skip the leading Elements value */
            else {       memcpy(ipo->Data + ipo->Used, Data,     Size); } /* copy everything */
         }
         else {          memset(ipo->Data + ipo->Used, 0,        Size); } /* set everything  */
         ipo->Used += Size;
      }
   }
   return(ipo);
}

/**
    \brief Free an U_PSEUDO_OBJ structure.  All associated memory is released.
    \param po   Address of a pointer to the U_PSEUDO_OBJ structure, Pointer is set to NULL.
    \returns 1 on success, 0 on error.
*/
int U_PO_free(U_PSEUDO_OBJ **po){
   if(!po)return(0);
   if(!*po)return(1);
   if((*po)->Data)free((*po)->Data);
   free(*po);
   *po=NULL;
   return(1);
}

/** \brief create a PseudoObject with data in the correct byte order for an EMF+ file.
    \returns The PseudoObject on success, NULL on error.

    \param Type  the type of the PseudoObject that is created.  Allowed values are in U_PID_Values.
    \param List  an array of U_SERIAL_DESC structures containing the data to store.

      The U_PMF_SERIAL_set() function should not ever be called directly by end user code.
    
   Each U_SERIAL_DESC element in List consists of Data fields and a description of that data.  List is terminated
     by the first U_SERIAL_DESC element having a TE value of U_XX.
   
   Data fields: an array of a basic type of Units bytes repeated Reps times with the target byte order
      described in TE. 
   
   Ptrs:  Address of the first byte of the data fields.

   Units: Number of bytes of in each data field unit

   Reps:  Number of repeats of the unit in data fields.
           If a Ptr is NULL, and Units*Reps is not zero, then Units*Reps 0x00 bytes are stored.
           If a Ptr is NULL, and Units*Reps is zero, this U_SERIAL_DESC is ignored.
           if a Ptr is NOT NULL, and Units * Reps is not zero, then the data is stored in the indicated byte order.
           If a Ptr is NOT NULL, and Units or Reps is zero an error is signaled.

   TE:   (Target Endian) the byte order in which to store each unit of a data field as defined in U_Endian.
         Byte swapping is only enabled when Units is 2 or 4.  In addition to the byte order values U_XE, U_LE,
         and U_BE, and the array terminator U_XX, the value may also be U_RP.  U_RP means there is only a 
         single unit in the data fields, but it is to be copied to the target Reps times.  That is, the data
         was passed in with a form of run length encoding.

   Creates an empty PseudoObject if all pointers are NULL and all sizes are zero.
 */
U_PSEUDO_OBJ *U_PMF_SERIAL_set(uint32_t Type, const U_SERIAL_DESC *List){
   U_PSEUDO_OBJ        *po=NULL;
   size_t               Total=0;
   size_t               FSize;
   char                *cptr;
   char                *hptr;
   const U_SERIAL_DESC *lptr;
   if(!List)return(NULL);
   for(lptr=List; lptr->TE != U_XX; lptr++){
      FSize = lptr->Units * lptr->Reps;
      if(!FSize && lptr->Ptr)return(po);
      Total += FSize;
   }
   po = U_PO_create(NULL, Total, Total, Type);
   if(po){
      cptr = po->Data;
      for(lptr=List; lptr->TE != U_XX; lptr++){
         FSize = lptr->Units * lptr->Reps;
         if(FSize){ /* Ptr is not NULL, that would have been detected already */
            hptr = cptr;
            if(lptr->TE & U_RP){  U_PMF_REPCPY_DSTSHIFT(&cptr, lptr->Ptr, lptr->Units, lptr->Reps); }
            else {                U_PMF_MEMCPY_DSTSHIFT(&cptr, lptr->Ptr, FSize);                   }
            if(((lptr->TE & U_LE) && U_IS_BE) || ((lptr->TE & U_BE) && U_IS_LE)){
               if(lptr->Units==2){      U_swap2(hptr,lptr->Reps); }
               else if(lptr->Units==4){ U_swap4(hptr,lptr->Reps); }
            }
         }
      }
   }
   return(po);
}

/**
    \brief Create U_DPSEUDO_OBJ's for the Points and Types of a path
    \param Elements Number of elements in Points.  May be zero, which creates an empty path.
    \param Points   Array of U_PMF_POINTF values.
    \param First    Apply to first point,      unsigned byte, lower 4 bits hold the PathPointType flag upper 4 bits hold the PathPointType enumeration. Must have U_PPT_Start set.
    \param Others   Apply to all other points, unsigned byte, lower 4 bits hold the PathPointType flag upper 4 bits hold the PathPointType enumeration. Must have U_PPT_Line or U_PPT_Bezier set.
    \returns pointer to the DU_PSEUDO_OBJ object, NULL on error
*/
U_DPSEUDO_OBJ *U_PATH_create(int Elements, const U_PMF_POINTF *Points, uint8_t First, uint8_t Others){
   if(Elements){
      if(!Points){                               return(NULL); }
      if( (First & U_PPT_MASK) != U_PPT_Start ){ return(NULL); }
      if(!(Others & U_PPT_Bezier)){              return(NULL); } /* will pass if either line or bezier is set */
   }
    
   U_DPSEUDO_OBJ *Path = (U_DPSEUDO_OBJ *)calloc(sizeof(U_DPSEUDO_OBJ),1); /* make poTypes and poPoints NULL */
   const U_SERIAL_DESC List[] = { {NULL,0,0,U_XX} };
   if(Path){
      Path->Elements = Elements;
      Path->poPoints = U_PMF_SERIAL_set(U_PMF_RAW_OID, List);  /* Empty PO to hold points as raw data */
      if(!Elements){
         Path->poTypes  = U_PMF_SERIAL_set(U_PMF_RAW_OID, List);  /* Empty PO to hold types as raw data */
      }
      else {
         Path->poPoints = U_PO_append(Path->poPoints, (char *)Points, Elements*sizeof(U_PMF_POINTF));
         if(Path->poPoints){
            U_PSEUDO_OBJ *tpo = U_PMF_PATHPOINTTYPE_set2(Elements, First | U_PPT_Start, Others);  /* PO holding types, has leading Elements value */
            Path->poTypes = U_PO_po_append(NULL, tpo, U_PMF_DROP_ELEMENTS); /* remove the leading Elements value*/
            U_PO_free(&tpo);
            if(!Path->poTypes){ U_PO_free(&Path->poPoints); }
         }
         if(!Path->poPoints){ U_DPO_free(&Path); }
      }
   }
   return(Path);
}

/**
    \brief Free U_DPSEUDO_OBJ's
    \returns 1 on success, 0 on error.
*/
int U_DPO_free(U_DPSEUDO_OBJ **dpo){
   if(!dpo){  return(0); }
   if(!*dpo){ return(1); }
   U_DPSEUDO_OBJ *kpo = *dpo;
   if(kpo->poPoints){ U_PO_free(&kpo->poPoints); }
   if(kpo->poTypes){  U_PO_free(&kpo->poTypes);  }
   free(*dpo);
   *dpo=NULL;
   return(1);
}

/**
    \brief Clear U_DPSEUDO_OBJ's.  Memory is retained, Elements and Used values are set to 0.
    \returns 1 on success, 0 on error.
    
    It is much more efficient to clear a DPO and reuse it than to free that DPO and create another.
*/
int U_DPO_clear(U_DPSEUDO_OBJ *dpo){
   if(!dpo){  return(0); }
   if(dpo->poPoints){ dpo->poPoints->Used = 0; }
   if(dpo->poTypes){  dpo->poTypes->Used  = 0; }
   dpo->Elements = 0;
   return(1);
}

/**
    \brief Append a "moveto" point to a path
    \param Path   Address of a DoublePseudoObject holding the path to append to.
    \param Point  Point to move to.
    \param Flags  Flags may be (U_PTP_None, U_PTP_DashMode, U_PTP_PathMarker, U_PTP_NoBit, U_PTP_CloseSubpath)
    \returns 1 on success, 0 on error.
*/
int U_PATH_moveto(U_DPSEUDO_OBJ *Path, U_PMF_POINTF Point, uint8_t Flags){
   if(!Path){ return(0); }
   U_PSEUDO_OBJ *tpo;
   U_PSEUDO_OBJ *tpo2;
   uint8_t Type = (Flags & U_PTP_NotClose) | U_PPT_Start;

   tpo = U_PMF_POINTF_set(1, &Point);
   if(!tpo){ return(0); }
   tpo2 = U_PO_po_append(Path->poPoints, tpo, U_PMF_DROP_ELEMENTS);
   U_PO_free(&tpo);
   if(!tpo2)return(0);
   Path->poPoints = tpo2;
   

   tpo  = U_PMF_PATHPOINTTYPE_set(1, &Type);
   if(!tpo){ return(0); }
   tpo2= U_PO_po_append(Path->poTypes, tpo, U_PMF_DROP_ELEMENTS);
   U_PO_free(&tpo);
   if(!tpo2)return(0);
   Path->poTypes = tpo2;

   Path->Elements++;
   return(1);
}

/**
    \brief Append a "lineto" point to a path
    \param Path    Address of a DoublePseudoObject holding the path to append to.
    \param Point   U_PMF_POINTF point to draw to.
    \param Flags  Flags may be (U_PTP_None, U_PTP_DashMode, U_PTP_PathMarker, U_PTP_NoBit, U_PTP_CloseSubpath)
    \returns 1 on success, 0 on error.
*/
int U_PATH_lineto(U_DPSEUDO_OBJ *Path,  U_PMF_POINTF Point, uint8_t Flags){
   if(!Path || !Path->Elements){ return(0); }  /* must be at least one point to extend from */
   if(Path->poTypes->Data[Path->Elements - 1] & U_PTP_CloseSubpath){ return(0); }  /* cannot extend a closed subpath */
   U_PSEUDO_OBJ *tpo;
   U_PSEUDO_OBJ *tpo2;
   uint8_t Type = (Flags & U_PTP_NotClose) | U_PPT_Line;
   tpo = U_PMF_POINTF_set(1, &Point);
   if(!tpo){ return(0); }
   tpo2 = U_PO_po_append(Path->poPoints, tpo, U_PMF_DROP_ELEMENTS);
   U_PO_free(&tpo);
   if(!tpo2)return(0);
   Path->poPoints  = tpo2;
   

   tpo  = U_PMF_PATHPOINTTYPE_set(1, &Type);
   if(!tpo){ return(0); }
   tpo2 = U_PO_po_append(Path->poTypes, tpo, U_PMF_DROP_ELEMENTS);
   U_PO_free(&tpo);
   if(!tpo2)return(0);
   Path->poTypes  = tpo2;

   Path->Elements++;
   return(1);
}

/**
    \brief Set the closepath bit in the last point
    \param Path    Address of a DoublePseudoObject holding the path to act upon.
    \returns 1 on success, 0 on error.
*/
int U_PATH_closepath(U_DPSEUDO_OBJ *Path){
   if(!Path || !Path->poTypes){ return(0); }
   uint32_t Elements = Path->Elements;
   uint8_t  *Type    = (uint8_t *)(Path->poTypes->Data) + Elements - 1;
   if(*Type & U_PPT_Start){ return(0); } /* single point closed path makes no sense */
   *Type =  *Type | U_PTP_CloseSubpath;
   return(1);
}

/**
    \brief Append a "polylineto" set of point to a path
    \param Path      Address of a DoublePseudoObject holding the path to append to.
    \param Elements  number of Points and Flags
    \param Points    Line points.
    \param Flags     Flags (U_PTP_None, U_PTP_DashMode, U_PTP_PathMarker, U_PTP_NoBit, but NOT U_PTP_CloseSubpath)
    \param StartSeg  If set, use U_PPT_Start PathPointType enumeration for first point, otherwise use U_PPT_Line.
    \returns 1 on success, 0 on error.
*/
int U_PATH_polylineto(U_DPSEUDO_OBJ *Path, uint32_t Elements, const U_PMF_POINTF *Points, uint8_t Flags, uint8_t StartSeg){
   if(!Path || !Points){ return(0); }
   if(!Elements){ return(1); } /* harmless - do nothing */
   U_PSEUDO_OBJ *tpo;
   U_PSEUDO_OBJ *tpo2;
   uint8_t First, Others;

   tpo = U_PMF_POINTF_set(Elements, Points);
   tpo2 = U_PO_po_append(Path->poPoints, tpo, U_PMF_DROP_ELEMENTS);
   U_PO_free(&tpo);
   if(!tpo2)return(0);
   Path->poPoints = tpo2;
   
   if(StartSeg){ First  = (Flags & U_PTP_NotClose) | U_PPT_Start; }
   else {        First  = (Flags & U_PTP_NotClose) | U_PPT_Line;  }
                 Others = (Flags & U_PTP_NotClose) | U_PPT_Line;  
   tpo  = U_PMF_PATHPOINTTYPE_set2(Elements, First, Others);
   if(!tpo){ return(0); }
   tpo2 = U_PO_po_append(Path->poTypes, tpo, U_PMF_DROP_ELEMENTS);
   U_PO_free(&tpo);
   if(!tpo2)return(0);
   Path->poTypes = tpo2;

   Path->Elements += Elements;
   return(1);
}


/**
    \brief Append a "polybezierto" set of point to a path
    \param Path      Address of a DoublePseudoObject holding the path to append to.
    \param Elements  number of Points
    \param Points    Bezier points.  Optional starting point, then N sets of 3, example: [P1] (Q12A Q12B P2) (Q23A Q23B P3).
    \param Flags     Flags (U_PTP_None, U_PTP_DashMode, U_PTP_PathMarker, U_PTP_NoBit, but NOT U_PTP_CloseSubpath)
    \param StartSeg  If set, use U_PPT_Start PathPointType enumeration for first point, otherwise use U_PPT_Bezier.
    \returns 1 on success, 0 on error.
    
    If Start is set   Elements must be 1 + multiple of 3. Ie, P1 Q12A Q12B P2 Q23A Q23B P3

    If Start is clear Elements must be a multiple of 3.   Ie, (P1, already in path) Q12A Q12B P2 Q23A Q23B P3
*/
int U_PATH_polybezierto(U_DPSEUDO_OBJ *Path, uint32_t Elements, const U_PMF_POINTF *Points, uint8_t Flags, uint8_t StartSeg){
   if(!Path || !Points){                  return(0); }
   if(!Elements){
      if(StartSeg){                       return(0); }    /* cannot have both a NEW segment and ZERO points */
      else{                               return(1); }    /* harmless - do nothing */
   }
   if(StartSeg  && ((Elements - 1) % 3)){ return(0); }    /* new segment    must be 1 + N*3 points */
   if(!StartSeg && (Elements % 3)){       return(0); }    /* extend segment must be     N*3 points */
   U_PSEUDO_OBJ *tpo;
   U_PSEUDO_OBJ *tpo2;
   uint8_t First, Others;

   tpo = U_PMF_POINTF_set(Elements, Points);
   tpo2 = U_PO_po_append(Path->poPoints, tpo, U_PMF_DROP_ELEMENTS);
   U_PO_free(&tpo);
   if(!tpo2)return(0);
   Path->poPoints = tpo2;
 
   if(StartSeg){ First  = (Flags & U_PTP_NotClose) | U_PPT_Start;  }
   else {        First  = (Flags & U_PTP_NotClose) | U_PPT_Bezier; }
                 Others = (Flags & U_PTP_NotClose) | U_PPT_Bezier;
   tpo  = U_PMF_PATHPOINTTYPE_set2(Elements, First, Others);
   if(!tpo){ return(0); }
   tpo2 = U_PO_po_append(Path->poTypes, tpo, U_PMF_DROP_ELEMENTS);
   U_PO_free(&tpo);
   if(!tpo2)return(0);
   Path->poTypes = tpo2;

   Path->Elements += Elements;
   return(1);
}

/**
    \brief Append a "polygon" set of points to a path.
    \param Path      Address of a DoublePseudoObject holding the path to append to.
    \param Elements  number of Points and Flags
    \param Points    Line points.
    \param Flags     Flags (U_PTP_None, U_PTP_DashMode, U_PTP_PathMarker, U_PTP_NoBit, but NOT U_PTP_CloseSubpath)
    \returns 1 on success, 0 on error.
*/
int U_PATH_polygon(U_DPSEUDO_OBJ *Path, uint32_t Elements, const U_PMF_POINTF *Points, uint8_t Flags){
   int status = U_PATH_polylineto(Path, Elements, Points, Flags, U_SEG_NEW);
   if(status){
       status = U_PATH_closepath(Path);
   }
   return(status);
}

//! \cond
// These are not exposed in the API
/* Parameterized Ellipse coordinates */
U_PMF_POINTF U_eparam(U_FLOAT a, U_FLOAT b, U_PMF_POINTF *center, double Ang, double Theta){
   U_PMF_POINTF point;
   point.X = center->X + a*cos(Theta)*cos(Ang) - b*sin(Theta)*sin(Ang);
   point.Y = center->Y + a*sin(Theta)*cos(Ang) + b*cos(Theta)*sin(Ang);
   return(point);
}

/* Parameterized Ellipse derivative  */
U_PMF_POINTF U_eparam2(U_FLOAT a, U_FLOAT b, double Ang, double Theta){
   U_PMF_POINTF point;
   point.X = -a*cos(Theta)*sin(Ang) - b*sin(Theta)*cos(Ang);
   point.Y = -a*sin(Theta)*sin(Ang) + b*cos(Theta)*cos(Ang);
   return(point);
}

double U_aparam(double Ang1, double Ang2){
   double Alpha;
   double t2;
   t2 = tan((Ang2 - Ang1)/2.0);
   t2 *= t2;
   Alpha = sin(Ang2 - Ang1) * (sqrt(4 + 3*t2) -1.0)/3.0;
   return(Alpha);
}

/* Parameterized Bezier point Q1 or Q2  derivative  */
U_PMF_POINTF U_qparam(double Alpha, double a, double b, U_PMF_POINTF *Point, double Ang, double Theta, int mode){
   U_PMF_POINTF Q, Prime;
   Prime = U_eparam2(a,b,Ang,Theta);
   if(mode==1){ /* Q1, anything else is Q2*/
      Q.X = Point->X + Alpha * Prime.X;
      Q.Y = Point->Y + Alpha * Prime.Y;
   }
   else {
      Q.X = Point->X - Alpha * Prime.X;
      Q.Y = Point->Y - Alpha * Prime.Y;
   }
   return(Q);
}
//! \endcond

/**
    \brief Append an "arcto" set of points to a path (Bezier points are calculated, and these are appended
    \param Path      Address of a pointer to the U_PSEUDO_OBJ that holds points
    \param Start     Start angle, >=0.0, degrees clockwise from 3:00
    \param Sweep     Sweep angle, -360<= angle <=360, degrees clockwise from Start
    \param Rot       Rotation angle to apply to coordinate system (Start and Rect), positive is degrees clockwise
    \param Rect      U_PMF_RECTF that defines the bounding rectangle.
    \param Flags     Flags (U_PTP_None, U_PTP_DashMode, U_PTP_PathMarker, U_PTP_NoBit, but NOT U_PTP_CloseSubpath)
    \param StartSeg  If set, the arc starts a new segment, if clear, continue the existing segment.  Starting a new segment does not automatically apply U_PATH_closepath to the existing path.
    \returns 1 on success, 0 on error.
    
    Based on Luc Maisonobe's work, http://www.spaceroots.org/documents/ellipse/
*/
int U_PATH_arcto(U_DPSEUDO_OBJ *Path, U_FLOAT Start, U_FLOAT Sweep, U_FLOAT Rot, U_PMF_RECTF *Rect, uint8_t Flags, int StartSeg){
   U_PMF_POINTF Bz[3];
   U_PMF_POINTF Center;
   U_PMF_POINTF P1,P2;
   double a, b;
   int done  = 0;
   int fpoint = 0;
   double L1, L2;     /* These are degrees CounterClockwise from 3:00 */
   double Ang1, Ang2; /* These are parametric angles, derived from L1, L2*/
   double Alpha;      /* Dimensionless number used for Q1, Q2 */
   double Theta;      /* Rot in radians */
   double Slop;       /* do not let rounding errors cause spurious end points */
   if(!Path){   return(0); }
   if((Sweep > 360.0) || (Sweep < -360.0)){ return(0); }
   /* Start should be between 0 and 360 degrees, but it does not really matter because sin, and cos will accept anything */
   /* the sign on Sweep and Start is correct bacause LM's derivation has y positive up, but GDI+ has y positive down. */
   a  = Rect->Width/2.0;
   b  = Rect->Height/2.0;
   if(!a || !b){ return(0); }
   Center.X = Rect->X + a;
   Center.Y = Rect->Y + b;
   /* convert to radians */
   Start = (2.0 * U_PI * Start)/360.0;
   Sweep = (2.0 * U_PI * Sweep)/360.0;
   Theta = (2.0 * U_PI * Rot  )/360.0;
   Slop  = Sweep/100000.0;
   L1 = Start;

   while(!done){
      if(Sweep < 0){
         L2 = L1 - U_PI/2.0;
         if(L2 <= Sweep + Start - Slop){ L2 = Sweep + Start; done = 1; }
         else {done = 0; }
      }
      else {
         L2 = L1 + U_PI/2.0;
         if(L2 >= Sweep + Start + Slop){ L2 = Sweep + Start; done = 1; }
         else {done = 0; }
      }
      Ang1 = atan2(sin(L1)/b, cos(L1)/a);
      Ang2 = atan2(sin(L2)/b, cos(L2)/a);
      Alpha = U_aparam(Ang1, Ang2);
      P1    = U_eparam(a, b, &Center, Ang1, Theta);        /* P1 */
      P2    = U_eparam(a, b, &Center, Ang2, Theta);        /* P2 */
      Bz[0] = U_qparam(Alpha, a, b, &P1, Ang1, Theta, 1);  /* Q1 */
      Bz[1] = U_qparam(Alpha, a, b, &P2, Ang2, Theta, 2);  /* Q2 */
      Bz[2] = P2;
      if(!fpoint){
         if(StartSeg){ U_PATH_moveto(Path, P1, Flags); }
         else {        U_PATH_lineto(Path, P1, Flags); }
         fpoint = 1;
      }
      U_PATH_polybezierto(Path, 3, Bz, Flags, U_SEG_OLD );
      L1 = L2;
   }
   return(1);
}

/**
    \brief Allocate and construct an array of U_PMF_POINTF objects which have been subjected to a U_XFORM
    \returns pointer to an array of U_PMF_POINTF structures.
    \param points  pointer to the source U_PMF_POINTF structures
    \param count   number of members in points
    \param xform   U_XFORM to apply
    
*/
U_PMF_POINTF *pointfs_transform(U_PMF_POINTF *points, int count, U_XFORM xform){
   U_PMF_POINTF *newpts=NULL;;
   int i;
   float X,Y;
   newpts = (U_PMF_POINTF *) malloc(count * sizeof(U_PMF_POINTF));
   if(newpts){
      for(i=0; i<count; i++){
         X = points[i].X;
         Y = points[i].Y;
         newpts[i].X = U_ROUND(X * xform.eM11 + Y * xform.eM21 + xform.eDx);
         newpts[i].Y = U_ROUND(X * xform.eM12 + Y * xform.eM22 + xform.eDy);
      }
   }
   return(newpts);
}

/**
    \brief Allocate and construct an array of U_PMF_RECTF objects which have been subjected to a U_XFORM
    \returns pointer to an array of U_PMF_RECTF structures.
    \param Rects   pointer to the source U_PMF_RECTF structures
    \param Count   number of members in Rects
    \param Xform   U_XFORM to apply.  Rotation is ignored, only translation is applied.
    
*/
U_PMF_RECTF *rectfs_transform(U_PMF_RECTF *Rects, int Count, U_XFORM Xform){
   U_PMF_RECTF *newRects;
   int i;
   newRects = (U_PMF_RECTF *) malloc(Count * sizeof(U_PMF_RECTF));
   if(newRects){
      for(i=0; i<Count; i++){
         newRects[i].X      = U_ROUND(Rects[i].X + Xform.eDx);
         newRects[i].Y      = U_ROUND(Rects[i].Y + Xform.eDy);
         newRects[i].Width  = U_ROUND(Rects[i].Width);
         newRects[i].Height = U_ROUND(Rects[i].Height);
      }
   }
   return(newRects);
}

/**
    \brief  Utility function calculate the transformation matrix needed to make a gradient run precisely corner to corner of a rectangle
    \param  Angle   Rotation in degrees clockwise of the gradient. 0 is horizontal gradient.
    \param  w       Width of the rectangle
    \param  h       Height of the rectangle
    \param  x       X coordinate of upper left corner of rectangle
    \param  y       Y coordinate of upper left corner of rectangle
    \param  Periods Periods of gradient corner to corner.  1.0 is one, corner to corner.
    \return Transformation matrix.  All values are zero if Periods, w, or h are less than or equal to zero.
*/
U_PMF_TRANSFORMMATRIX tm_for_gradrect(U_FLOAT Angle, U_FLOAT w, U_FLOAT h, U_FLOAT x, U_FLOAT y, U_FLOAT Periods){
//! \cond
#define CLOSE_TO_IS_REALLY_ZERO(A) ((A) > 1.0e-10 || (A) < -1.0e-10 ? (A) : 0.0) //! \hideinitializer 
//! \endcond
   U_PMF_TRANSFORMMATRIX tm;
   double dang = Angle * 2*U_PI /360.0;
   double scale;
   double cd,sd;
   if((Periods <=0.0) || (w <= 0.0) || (h <= 0.0)){
      tm.m11 = tm.m12 = tm.m21 = tm.m22 = tm.dX = tm.dY = 0.0;
   }
   else {
      /*
        scale is gradient period divided by w
        The scale value sets the gradient period to match exactly with the inscribed (w,h) rectangle
          in the direction specified by the angle.
        The numberator of scale is the max of the four dot product values of the rotated X basis unit vector with (w,h),
          with each of the vectors {w,h}, {-w,h}, {-w,-h}, {w,h}.  Those vectors run from each corner in turn
          to the opposite corner.  The one most parallel to the rotated unit vector will have both terms positive.
          
        Trig results like cos(pi/2) are not stable between platforms due to minor differences in the
          implementation. Detect these and make them zero, which then allows binary comparison of output files.
          Otherwise the binary comparisons between platforms would fail because of a bunch of insignificant digits.
      */
      cd = CLOSE_TO_IS_REALLY_ZERO(cos(dang));
      sd = CLOSE_TO_IS_REALLY_ZERO(sin(dang));
      scale = (w*fabs(cd) + h*fabs(sd))/(w*Periods);
      tm.m11 =  scale * cd;
      tm.m12 = -scale * sd;                
      tm.m21 =  scale * sd;                
      tm.m22 =  scale * cd; 
      /* offset is to one corner of the square, depending on which quadrant the rotation selects. */
      if(cos(dang)>=0){
         tm.dX = x;
         if(sin(dang)>=0){tm.dY = y + h;  } // LL corner
         else {           tm.dY = y;      } // UL corner
      }
      else {
         tm.dX = x + w;
         if(sin(dang)>=0){ tm.dY = y + h; } // LR corner
         else {            tm.dY = y;     } // UR corner
      }
   }
   return tm; 
#undef CLOSE_TO_IS_REALLY_ZERO
}
/**
    \brief Create a U_PSEUDO_OBJ containing a U_PMR_FILLPATH and U_PMR_DRAWPATH records.
    \returns pointer to U_PSEUDO_OBJ or NULL on error.
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
*/
U_PSEUDO_OBJ *U_PMR_drawfill(uint32_t PathID, uint32_t PenID, const U_PSEUDO_OBJ *BrushID){
   U_PSEUDO_OBJ *po = U_PMR_FILLPATH_set(PathID, BrushID);
   if(po){
      U_PSEUDO_OBJ *tpo = U_PMR_DRAWPATH_set(PathID, PenID);
      po = U_PO_po_append(po, tpo, U_PMF_KEEP_ELEMENTS);
      U_PO_free(&tpo);
   }
   return(po);
}



/**
   \brief Extract a single data field from a source.
   \returns 1 on success, 0 on error.
   \param Src   where the data is coming from.  It is incremented by the number of bytes retrieved.
   \param Dst   where the data will be stored.  This must either be NULL (in which case the Src
           is advanced and nothing is stored, or it must be allocated to Reps * Units bytes!!!!
   \param Units number of bytes in each unit of the data field
   \param Reps  number of repeats of units in the data field.
           If a Ptr is NULL, then Units*Reps 0 bytes are stored.
           If a Ptr is NOT NULL, and Units or Reps, is zero an error is signaled.
           If a Ptr is NULL and Units*Reps is 0, nothing happens.
   \param SE    logical (Source Endian). Only relevant for Sizes of 2 or 4 
         Indicates when Bytes may need to be rearranged when they are retrieved.
         U_XE no change   (this is used when the data has already been set to the proper orientation or it is not known)
         U_LE source is Little Endian
         U_BE source is Big Endian.
         U_XX error
    
*/
int U_PMF_SERIAL_get(const char **Src, void *Dst, size_t Units, size_t Reps, int SE){
   if(!Src || !*Src || SE == U_XX){ return(0); }
   U_PMF_MEMCPY_SRCSHIFT(Dst, Src, Units * Reps);
   if(!Dst){                  return(1); } /* "fake" get, no data was retrieved, so we are done */
   if(SE == U_XE){            return(1); }
   if(SE == U_LE && U_IS_LE){ return(1); }
   if(SE == U_BE && U_IS_BE){ return(1); }
   /* need to swap */
   if(     Units==2){ U_swap2(Dst,Reps); }
   else if(Units==4){ U_swap4(Dst,Reps); }
   return(1);
}

/**
      \brief Conditionally extract an array of data from a source, allocating space to hold it.
      \returns 1 on success, 0 on error.
      \param Src   where the data is coming from.  It is incremented by the number of bytes retrieved.
      \param Dst   Caller must free.  Where the pointer to the data will be stored.  Reps * Units bytes will be allocated,
      \param Units number of bytes in each unit of the data field
      \param Reps  number of repeats of units in the data field.
           If a Ptr is NULL, then Units*Reps 0 bytes are stored.
           If a Ptr is NOT NULL, and Units or Reps, is zero an error is signaled.
           If a Ptr is NULL and Units*Reps is 0, nothing happens.
      \param SE    logical (Source Endian). Only relevant for Sizes of 2 or 4 
         Indicates when Bytes may need to be rearranged when they are retrieved.
         U_XE no change   (this is used when the data has already been set to the proper orientation or it is not known)
         U_LE source is Little Endian
         U_BE source is Big Endian.
         U_XX error
      \param Cond  Store the data into *Dst if true, set *Dst to NULL otherwise.
    
*/
int U_PMF_SERIAL_array_copy_get(const char **Src, void **Dst, size_t Units, size_t Reps, int SE, int Cond){
   if(!Src || !*Src || !Dst || SE == U_XX){ return(0); }
   if(!Cond){
      *Src += Units * Reps;
      *Dst = NULL;
      return(1);
   }
   *Dst = malloc(Units * Reps);
   if(!*Dst){                 return(1); } /* "fake" get, no data was retrieved, so we are done */
   U_PMF_MEMCPY_SRCSHIFT(*Dst, Src, Units * Reps);
   if(SE == U_XE){            return(1); }
   if(SE == U_LE && U_IS_LE){ return(1); }
   if(SE == U_BE && U_IS_BE){ return(1); }
   /* need to swap */
   if(     Units==2){ U_swap2(*Dst,Reps); }
   else if(Units==4){ U_swap4(*Dst,Reps); }
   return(1);
}



/**
    \brief Calculate the length in bytes of a relative path object composed of U_PMF_INTEGER7 and U_PMF_INTER15 values
    \return >=0 length == success, <0  error
    \param  contents   Start of a relative path consisting of int7 and int15 X,Y pairs.
    \param  Elements   number of relative X,Y pairs in the object
*/
int U_PMF_LEN_REL715(const char *contents, int Elements){
   int length=0;
   Elements *= 2; /* N pairs = 2N values */
   for( ; Elements; Elements--){
      /* X or Y value */
      if(*contents & U_TEST_INT7){ contents +=2; length +=2; } //int15
      else {                       contents +=1; length +=1; } //int7
   }
   return(length);
}

/**
    \brief Calculate the length in bytes of objects which are a 4 byte Count followed by Count * float bytes
    \return >=0 length == success, <0  error
    Object types whose size may be derived with this function are:
       U_PMF_COMPOUNDLINEDATA
       U_PMF_DASHEDLINEDATA    
*/
int U_PMF_LEN_FLOATDATA(const char *contents){
   int Size;
   U_PMF_SERIAL_get(&contents, &Size, 4, 1, U_LE);
   Size = 4*Size + 4;
   return(Size);
}

/**
    \brief Calculate the length in bytes of objects which are a 4 byte count followed by count bytes
    \return >=0 length == success, <0  error
    Object types whose size may be derived with this function are:
       U_PMF_BOUNDARYPATHDATA
       U_PMF_BOUNDARYPOINTDATA
       U_PMF_CUSTOMSTARTCAPDATA
       U_PMF_PATH
       U_PMF_LINEPATH
       U_PMF_REGIONNODEPATH
*/
int U_PMF_LEN_BYTEDATA(const char *contents){
   int Size;
   U_PMF_SERIAL_get(&contents, &Size, 4, 1, U_LE);
   Size += 4;
   return(Size);
}

/**
    \brief Create a string containing the curly bracket form of the 16 byte GUID value
    \return number of bytes in record, 0 on error
    \param  GUID   pointer to the 16 unsigned bytes
    \return string in curly bracket form.
    http://msdn.microsoft.com/en-us/library/cc230316.aspx

    Text form is Data1-Data2-Data3-Data4, the first 3 are stored as little endian integers, the last as a string (big endian).
*/
char *U_PMF_CURLYGUID_set(uint8_t *GUID){
   char *string=malloc(64);
   if(string){
      sprintf(string,"{%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X}",         
         GUID[3],GUID[2],GUID[1],GUID[0],
         GUID[5],GUID[4],
         GUID[7],GUID[6],
         GUID[8],GUID[9],
         GUID[10],GUID[11],GUID[12],GUID[13],GUID[14],GUID[15]
      );
   }
   return(string);
}

/**
    \brief Identify a known curly GUID
    \param  string   Curly GUID form.
    \return EmageEffects Enumerator 

    EMF+ manual 2.1.3.1, Microsoft name: ImageEffects Identifier
*/
int U_PMF_KNOWNCURLYGUID_set(const char *string){
   int status; 
   if(     !strcmp(string,"{633C80A4-1843-482B-9EF2-BE2834C5FDD4}")){ status = U_IEE_BlurEffectGuid;                  }                                                     
   else if(!strcmp(string,"{D3A1DBE1-8EC4-4C17-9F4C-EA97AD1C343D}")){ status = U_IEE_BrightnessContrastEffectGuid;    }
   else if(!strcmp(string,"{537E597D-251E-48DA-9664-29CA496B70F8}")){ status = U_IEE_ColorBalanceEffectGuid;          }
   else if(!strcmp(string,"{DD6A0022-58E4-4A67-9D9B-D48EB881A53D}")){ status = U_IEE_ColorCurveEffectGuid;            }
   else if(!strcmp(string,"{A7CE72A9-0F7F-40D7-B3CC-D0C02D5C3212}")){ status = U_IEE_ColorLookupTableEffectGuid;      }
   else if(!strcmp(string,"{718F2615-7933-40E3-A511-5F68FE14DD74}")){ status = U_IEE_ColorMatrixEffectGuid;           }
   else if(!strcmp(string,"{8B2DD6C3-EB07-4D87-A5F0-7108E26A9C5F}")){ status = U_IEE_HueSaturationLightnessEffectGuid;}
   else if(!strcmp(string,"{99C354EC-2A31-4F3A-8C34-17A803B33A25}")){ status = U_IEE_LevelsEffectGuid;                }
   else if(!strcmp(string,"{74D29D05-69A4-4266-9549-3CC52836B632}")){ status = U_IEE_RedEyeCorrectionEffectGuid;      }
   else if(!strcmp(string,"{63CBF3EE-C526-402C-8F71-62C540BF5142}")){ status = U_IEE_SharpenEffectGuid;               }
   else if(!strcmp(string,"{1077AF00-2848-4441-9489-44AD4C2D7A2C}")){ status = U_IEE_TintEffectGuid;                  }
   else {                                                             status = U_IEE_Unknown;                         }
   return(status);
}

/** \brief Load a GUID from text format into EMF+ file binary format.
    \param  string  Curly GUID as text, minus the barckets and dashes.
    \return GUID in EMF+ file binary format.


This accepts a string that is 16 bytes long = 32 characters hex (no dash spaces or brackets) as text.  
Text form is; Data1|Data2|Data3|Data4, first three are stored as little endian integers of 4,2,2 bytes, respectively,
last is stored like a string (big endian), after conversion from text hex to binary.

This function is not normally called by end user code.
*/
uint8_t *U_LOAD_GUID(char *string){
   uint32_t Data1,tData2,tData3,tByte;
   uint16_t Data2,Data3;
   char    *Data4 = string + 16;
   uint8_t *hold  = malloc(16);
   char    *lf    = (char *) hold;
   int      i;
   if(hold){
      Data1=tData2=tData3=0;               
      if(3 != sscanf(string +  0,"%8X",&Data1)  + 
              sscanf(string +  8,"%4X",&tData2) + 
              sscanf(string + 12,"%4X",&tData3)){
         free(hold);
         hold = NULL;
         goto bye;
      }
      Data2=tData2;
      Data3=tData3;
      U_PMF_MEMCPY_DSTSHIFT(&lf, &Data1, 4);
      U_PMF_MEMCPY_DSTSHIFT(&lf, &Data2, 2);
      U_PMF_MEMCPY_DSTSHIFT(&lf, &Data3, 2);
      if(U_IS_BE){ /* these fields are stored little endian */
         U_swap4(hold,1);
         U_swap2(hold+4,2);
      }
      /* remainder is converted byte by byte and stored in that order */
      for(i=0;i<8;i++,Data4+=2,lf++){
         if(1 != sscanf(Data4,"%2X",&tByte)){
            free(hold);
            hold = NULL;
            goto bye;
         }
         *lf=tByte;
      }
   }
bye:
   return(hold);
}

/**
    \brief Generate the 16 byte form from OID of the ImageEffects Identifier
    \param  OID  OID of the ImageEffects Identifier
    \return pointer to 16 byte buffer holding the long GUID binary form, or NULL on error.

    EMF+ manual 2.1.3.1, Microsoft name: ImageEffects Identifier
*/
uint8_t *U_OID_To_GUID(uint32_t OID){
   uint8_t *lf = NULL;
   if(     OID == U_PMF_IE_BLUR_OID                  ){ lf = U_LOAD_GUID("633C80A41843482B9EF2BE2834C5FDD4"); } 
   else if(OID == U_PMF_IE_BRIGHTNESSCONTRAST_OID    ){ lf = U_LOAD_GUID("D3A1DBE18EC44C179F4CEA97AD1C343D"); } 
   else if(OID == U_PMF_IE_COLORBALANCE_OID          ){ lf = U_LOAD_GUID("537E597D251E48DA966429CA496B70F8"); } 
   else if(OID == U_PMF_IE_COLORCURVE_OID            ){ lf = U_LOAD_GUID("DD6A002258E44A679D9BD48EB881A53D"); } 
   else if(OID == U_PMF_IE_COLORLOOKUPTABLE_OID      ){ lf = U_LOAD_GUID("A7CE72A90F7F40D7B3CCD0C02D5C3212"); } 
   else if(OID == U_PMF_IE_COLORMATRIX_OID           ){ lf = U_LOAD_GUID("718F2615793340E3A5115F68FE14DD74"); } 
   else if(OID == U_PMF_IE_HUESATURATIONLIGHTNESS_OID){ lf = U_LOAD_GUID("8B2DD6C3EB074D87A5F07108E26A9C5F"); } 
   else if(OID == U_PMF_IE_LEVELS_OID                ){ lf = U_LOAD_GUID("99C354EC2A314F3A8C3417A803B33A25"); } 
   else if(OID == U_PMF_IE_REDEYECORRECTION_OID      ){ lf = U_LOAD_GUID("74D29D0569A4426695493CC52836B632"); } 
   else if(OID == U_PMF_IE_SHARPEN_OID               ){ lf = U_LOAD_GUID("63CBF3EEC526402C8F7162C540BF5142"); } 
   else if(OID == U_PMF_IE_TINT_OID                  ){ lf = U_LOAD_GUID("1077AF0028484441948944AD4C2D7A2C"); }
   return(lf);
}

/**
    \brief copy data and shift source pointer by the amount of data moved
    \param Dst Destination in memory
    \param Src Source in memory
    \param Size Number of bytes to move
*/
void U_PMF_MEMCPY_SRCSHIFT(void *Dst, const char **Src, size_t Size){
   if(Dst)memcpy(Dst, *Src, Size);
   *Src += Size;
}

/**
    \brief copy data and shift destination pointer by the amount of data moved
    \param Dst Destination in memory (this must not be NULL)
    \param Src Source in memory (if this is NULL, fill with that many zero bytes instead)
    \param Size Number of bytes to move
*/
void U_PMF_MEMCPY_DSTSHIFT(char **Dst, const void *Src, size_t Size){
   if(Src){ memcpy(*Dst, Src, Size); }
   else {   memset(*Dst, 0,   Size); }
   *Dst += Size;
}

/**
    \brief Copy the single instance at Src repeatedly to Dst.
    \param Dst   Destination in memory
    \param Src   Source in memory (if this is NULL, fill with that many zero bytes instead)
    \param Size  number of bytes in single instance that is template.
    \param Reps  Number of instances of the template to opy
*/
void U_PMF_REPCPY_DSTSHIFT(char **Dst, const void *Src, size_t Size, size_t Reps){
   for(;Reps;Reps--){
      if(Src){ memcpy(*Dst, Src, Size); }
      else {   memset(*Dst, 0,   Size); }
      *Dst += Size;
   }
}

/**
    \brief save pointer to data and shift source pointer by the amount of data moved
    \param Dst Destination in memory
    \param Src Source in memory or NULL. If NULL Dst is set to NULL.
    \param Size Number of bytes to move
*/
void U_PMF_PTRSAV_SHIFT(const char **Dst, const char **Src, size_t Size){
   if(*Src){
      if(Dst)*Dst = *Src;
      *Src += Size;
   }
   else {
      if(Dst)*Dst = NULL;
   }
}

/**
    \brief save pointer to data and shift source pointer by the amount of data moved
    \return 1 on sucess, 0 on error
    \param Dst Destination in memory
    \param Src Source in memory or NULL. If NULL Dst is set to NULL.
    \param Doit Assign if true, otherwise, set to NULL
*/
int U_PMF_PTRSAV_COND(const char **Dst, const char *Src, int Doit){
   if(!Dst){ return(0); }
   if(Src && Doit){ *Dst = Src;  }
   else {           *Dst = NULL; }
   return(1);
}
/*

   =====================================================================================
   start of U_PMF_*_get() functions 

*/

/**
    \brief Get the 16 bit unsigned Flags field from a header.
    \param  contents   Record from which to extract data, will be incremented by header size.
    \return Flags field

    In many records the only value needed from the header is Flags.  Rather than mapping
    the entire Header and returning it, in these instances this function may be called to
    just get this one value.
*/
uint16_t U_PMF_HEADERFLAGS_get(const char *contents){
   uint16_t Flags;
   const char *cptr = contents + offsetof(U_PMF_CMN_HDR,Flags);
   U_PMF_SERIAL_get(&cptr, &Flags,  2, 1, U_LE); /* EMF+ manual documents it as BE, but this code implements it as LE*/
   return(Flags);
}

/**
    \brief Retrieve whichever header fields are requested.  NULL pointers do not retrieve.
    \param  contents   Record from which to extract data, will be incremented by header size.
    \param  Type       Record type
    \param  Flags      Record flags
    \param  Size       Records size
    \param  Datasize   Data size
    \return 1 on success, 0 on failure.
*/
int U_PMF_HEADERFIELDS_get(const char *contents,
   uint16_t *Type, uint16_t *Flags, uint32_t *Size, uint32_t *Datasize){
   if(!contents){ return(0); }
   U_PMF_SERIAL_get(&contents, Type,     2, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Flags,    2, 1, U_LE); /* EMF+ manual documents it as BE, but this code implements it as LE*/
   U_PMF_SERIAL_get(&contents, Size,     4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Datasize, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get the entire EMF+ record header.
    \param  contents   Record from which to extract data, will be offset by header size.
    \param  Header     Location to store data (may be NULL)
    \returns 1
    If Header is Null, nothing is stored but contents is still offset.
*/
int U_PMF_CMN_HDR_get(const char **contents, U_PMF_CMN_HDR *Header){
   if(!contents || !*contents){ return(0); }
   if(Header){
      U_PMF_SERIAL_get(contents, &(Header->Type),     2, 1, U_LE);
      U_PMF_SERIAL_get(contents, &(Header->Flags),    2, 1, U_LE); /* EMF+ manual documents it as BE, but this code implements it as LE*/
      U_PMF_SERIAL_get(contents, &(Header->Size),     4, 1, U_LE);
      U_PMF_SERIAL_get(contents, &(Header->DataSize), 4, 1, U_LE);
   }
   else {
      *contents += sizeof(U_PMF_CMN_HDR);
   }
   return(1);
}

/**
    \brief return the size in bytes of the EMF+ record
    \param  contents   Record from which to extract data, will not be modified.
    \returns size, or 0 if contents is Null
*/
int U_PMF_RECORD_SIZE_get(const char *contents){
   if(!contents){ return(0); }
   int Size;
   const char *from = contents + 4;
   U_PMF_SERIAL_get(&from, &Size, 4, 1, U_LE);
   return(Size);
}

/**
    \brief Return the size of a PenData object from an EMF+ record.
    \param  PenData   Address in memory where the PenData object starts.
    \returns size of the object in bytes
*/
int U_PMF_LEN_PENDATA(const char *PenData){
   uint32_t Flags;
   int length=12;  /* Flags, Unit, Width */
   U_PMF_SERIAL_get(&PenData, &Flags,  4, 1, U_LE);
   PenData += 8;  /* skip Unit and Width */
   length  += U_PMF_LEN_OPTPENDATA(PenData, Flags);
   return(length);
}

/**
    \brief Return the size of an OptPenData object from an EMF+ record.
    \param  PenData   Address in memory where the PenData object starts.
    \param  Flags     PenData Flags that indicate which fields are present.
    \returns size of the object in bytes
*/
int U_PMF_LEN_OPTPENDATA(const char *PenData, uint32_t Flags){
   int length=0;
   if(Flags & U_PD_Transform){       length += sizeof(U_PMF_TRANSFORMMATRIX);           }
   if(Flags & U_PD_StartCap){        length += sizeof(int32_t);                         }
   if(Flags & U_PD_EndCap){          length += sizeof(int32_t);                         }
   if(Flags & U_PD_Join){            length += sizeof(uint32_t);                        }
   if(Flags & U_PD_MiterLimit){      length += sizeof(U_FLOAT);                         }
   if(Flags & U_PD_LineStyle){       length += sizeof(int32_t);                         }
   if(Flags & U_PD_DLCap){           length += sizeof(int32_t);                         }
   if(Flags & U_PD_DLOffset){        length += sizeof(int32_t);                         }
   if(Flags & U_PD_DLData){          length += U_PMF_LEN_FLOATDATA(PenData + length);   }
   if(Flags & U_PD_NonCenter){       length += sizeof(int32_t);                         }
   if(Flags & U_PD_CLData){          length += U_PMF_LEN_FLOATDATA(PenData + length);   }
   if(Flags & U_PD_CustomStartCap){  length += U_PMF_LEN_BYTEDATA(PenData + length);    }
   if(Flags & U_PD_CustomEndCap){    length += U_PMF_LEN_BYTEDATA(PenData + length);    }
   return(length);
}

/**
    \brief  Create and set a U_PMF_BRUSH PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  Bd         U_PSEUDO_OBJ containing one of the 5 types of Brush data

    EMF+ manual 2.2.1.1, Microsoft name: EmfPlusBrush Object
*/
U_PSEUDO_OBJ *U_PMF_BRUSH_set(uint32_t Version, const U_PSEUDO_OBJ *Bd){
   if(!Bd){ return(NULL); }
   int32_t Type = U_OID_To_BT(Bd->Type);
   if(Type < 0){ return(NULL); }
   const U_SERIAL_DESC List[] = {
      {&Version, 4,        1, U_LE},
      {&Type,    4,        1, U_LE},
      {Bd->Data, Bd->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_BRUSH_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_CUSTOMLINECAP PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  Ld         U_PSEUDO_OBJ containing one of the 2 types of Linecap data

    EMF+ manual 2.2.1.2, Microsoft name: EmfPlusCustomLineCap Object
*/
U_PSEUDO_OBJ *U_PMF_CUSTOMLINECAP_set(uint32_t Version, const U_PSEUDO_OBJ *Ld){
   if(!Ld){ return(NULL); }
   int32_t Type = U_OID_To_CLCDT(Ld->Type);
   if(Type<0){ return(NULL); }
   const U_SERIAL_DESC List[] = {
      {&Version, 4,        1, U_LE},
      {&Type,    4,        1, U_LE},
      {Ld->Data, Ld->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_CUSTOMLINECAP_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_FONT PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  EmSize     em size in units of SizeUnit
    \param  SizeUnit   UnitType enumeration
    \param  FSFlags    FontStyle flags
    \param  Length     Number of Unicode Characters in FamilyName
    \param  Font       Unicode (UTF-16LE) fontname

    EMF+ manual 2.2.1.3, Microsoft name: EmfPlusFont Object
*/
U_PSEUDO_OBJ *U_PMF_FONT_set(uint32_t Version, U_FLOAT EmSize, uint32_t SizeUnit,
      int32_t FSFlags, uint32_t Length, const uint16_t *Font){
   uint32_t cbFont = 2 * wchar16len(Font); /* this need not be 2*Length parameter */
   uint32_t pad = (0x3 & cbFont ? 2 : 0);
   const U_SERIAL_DESC List[] = {
      {&Version, 4,      1,             U_LE},
      {&EmSize,  4,      1,             U_LE},
      {&SizeUnit,4,      1,             U_LE},
      {&FSFlags, 4,      1,             U_LE},
      {NULL,     4,      1,             U_LE},  /* NULL is for Reserved field */
      {&Length,  4,      1,             U_LE},
      {Font,     cbFont, 1,             U_LE},
      {NULL,     pad,    (pad ? 1 : 0), (pad ? U_XE : U_XX)}, /* Entire record must be a multiple of 4 */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_FONT_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IMAGE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  Id         U_PSEUDO_OBJ containing one of the 2 types of image data

    EMF+ manual 2.2.1.4, Microsoft name: EmfPlusImage Object
*/
U_PSEUDO_OBJ *U_PMF_IMAGE_set(uint32_t Version, const U_PSEUDO_OBJ *Id){
   if(!Id){ return(NULL); }
   int32_t Type = U_OID_To_IDT(Id->Type);
   if(Type<0){ return(NULL);}
   const U_SERIAL_DESC List[] = {
      {&Version, 4,        1, U_LE},
      {&Type,    4,        1, U_LE},
      {Id->Data, Id->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IMAGE_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IMAGEATTRIBUTES PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Version     EmfPlusGraphicsVersion object
    \param  WrapMode    WrapMode object
    \param  ClampColor  EmfPlusARGB object
    \param  ObjectClamp ObjectClamp Identifiers

    EMF+ manual 2.2.1.5, Microsoft name: EmfPlusImageAttributes Object
*/
U_PSEUDO_OBJ *U_PMF_IMAGEATTRIBUTES_set(uint32_t Version, uint32_t WrapMode, uint32_t ClampColor, uint32_t ObjectClamp){
   uint32_t Reserved=0;
   const U_SERIAL_DESC List[] = {
      {&Version,     4, 1, U_LE},
      {&Reserved,    4, 1, U_LE},
      {&WrapMode,    4, 1, U_LE},
      {&ClampColor,  4, 1, U_LE},
      {&ObjectClamp, 4, 1, U_LE},
      {&Reserved,    4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IMAGEATTRIBUTES_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_PATH PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  Points     U_PSEUDO_OBJ containing array of points (of type PMFPointR, PMFPoint, or PMFPointF, determined by U_PPF_P and U_PPF_C bits in Flags)
    \param  Types      U_PSEUDO_OBJ containing array of types (U_PMF_PATHPOINTTYPE or U_PMF_PATHPOINTTYPERLE, determined by  U_PPF_R big in Flags)

    EMF+ manual 2.2.1.6, Microsoft name: EmfPlusPath Object
*/
U_PSEUDO_OBJ *U_PMF_PATH_set(uint32_t Version, const U_PSEUDO_OBJ *Points, const U_PSEUDO_OBJ *Types){
   int ctype, RelAbs, rtype;
   int pad;
   if(Points){
      if(     Points->Type == U_PMF_POINTR_OID){                               RelAbs = 1; ctype = 0; }
      else if(Points->Type == (U_PMF_POINT_OID  | U_PMF_ARRAY_OID)){           RelAbs = 0; ctype = 1; }
      else if(Points->Type == (U_PMF_POINTF_OID | U_PMF_ARRAY_OID)){           RelAbs = 0; ctype = 0; }
      else {                                                                   return(NULL);          }
   }
   else {                                                                      return(NULL);          }
   if(Types){
      if(     Types->Type  == (U_PMF_PATHPOINTTYPERLE_OID | U_PMF_ARRAY_OID)){ rtype = 1;             }
      else if(Types->Type  == (U_PMF_PATHPOINTTYPE_OID | U_PMF_ARRAY_OID)){    rtype = 0;             }
      else {                                                                   return(NULL);          }
   }
   else {                                                                      return(NULL);          }
   uint16_t Flags = (rtype ? U_PPF_R : 0) | (ctype ? U_PPF_C : 0)| (RelAbs ? U_PPF_P : 0);
   pad = (0x3 & (Points->Used + Types->Used));
   if(pad){ pad = 4 - pad; }
   const U_SERIAL_DESC List[] = {
      {&Version,         4,                1,             U_LE               },
      {Points->Data,     4,                1,             U_XE               }, /* Elements from Points */
      {&Flags,           2,                1,             U_LE               },
      {NULL,             2,                1,             U_LE               }, /* Reserved field */
      {Points->Data + 4, Points->Used - 4, 1,             U_XE               }, /* omit Points Elements */
      {Types->Data +4,   Types->Used - 4,  1,             U_XE               }, /* omit Types  Elements */
      {NULL,             pad,              (pad ? 1 : 0), (pad ? U_XE : U_XX)}, /* if no padding is needed the Units will be zero and nothing will happen */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PATH_OID, List);
   return(po);
}


/**
    \brief  Create and set a U_PMF_PATH PseudoObject that uses U_PMF_POINTF coordinates
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  Path       U_DPSEUDO_OBJ containing a path.

    EMF+ manual 2.2.1.6, Microsoft name: EmfPlusPath Object
*/
U_PSEUDO_OBJ *U_PMF_PATH_set2(uint32_t Version, const U_DPSEUDO_OBJ *Path){
   if(!Path || !Path->Elements){ return(NULL); }
   uint16_t Flags = 0;
   int pad = (0x3 & Path->Elements);
   if(pad){ pad = 4 - pad; }
   const U_SERIAL_DESC List[] = {
      {&Version,               4,                1,               U_LE               },
      {&Path->Elements,        4,                1,               U_LE               },
      {&Flags,                 2,                1,               U_LE               },
      {NULL,                   2,                1,               U_LE               }, /*  Reserved field */
      {Path->poPoints->Data,   4,                2*Path->Elements,U_XE               }, /*  raw OID, so no leading Elements to omit */
      {Path->poTypes->Data,    1,                Path->Elements,  U_XE               }, /*  raw OID, so no leading Elements to omit */
      {NULL,                   pad,              (pad ? 1 : 0),   (pad ? U_XE : U_XX)}, /* if no padding is needed the Units will be zero and nothing will happen */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PATH_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_PATH PseudoObject that uses U_PMF_POINT (int 16) coordinates
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  Path       U_DPSEUDO_OBJ containing a path.

    EMF+ manual 2.2.1.6, Microsoft name: EmfPlusPath Object
*/
U_PSEUDO_OBJ *U_PMF_PATH_set3(uint32_t Version, const U_DPSEUDO_OBJ *Path){
   if(!Path || !Path->Elements){return(NULL);  }
   uint16_t Flags = U_PPF_C;
   int pad = (0x3 & Path->Elements);
   if(pad){ pad = 4 - pad; }
   U_PMF_POINT *Points16 = POINTF_To_POINT16_LE((U_PMF_POINTF *)Path->poPoints->Data, Path->Elements);
   if(!Points16){ return(NULL); }
   const U_SERIAL_DESC List[] = {
      {&Version,               4,                1,               U_LE               },
      {&Path->Elements,        4,                1,               U_LE               },
      {&Flags,                 2,                1,               U_LE               },
      {NULL,                   2,                1,               U_LE               }, /*  Reserved field */
      {Points16,               2,                2*Path->Elements,U_XE               }, /*  raw data, so no leading Elements to omit */
      {Path->poTypes->Data,    1,                Path->Elements,  U_XE               }, /*  raw data, so no leading Elements to omit */
      {NULL,                   pad,              (pad ? 1 : 0),   (pad ? U_XE : U_XX)}, /* if no padding is needed the Units will be zero and nothing will happen */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PATH_OID, List);
   free(Points16);
   return(po);
}

/**
    \brief  Create and set a U_PMF_PEN PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  PenData    U_PSEUDO_OBJ containing U_PMF_PENDATA object
    \param  Brush      U_PSEUDO_OBJ containing U_PMF_BRUSH object 

    EMF+ manual 2.2.1.7, Microsoft name: EmfPlusPen Object
*/
U_PSEUDO_OBJ *U_PMF_PEN_set(uint32_t Version, const U_PSEUDO_OBJ *PenData, const U_PSEUDO_OBJ *Brush){
   if(!PenData   || (PenData->Type    != U_PMF_PENDATA_OID)){ return(NULL); }
   if(!Brush     || (Brush->Type      != U_PMF_BRUSH_OID)  ){ return(NULL); }
   const U_SERIAL_DESC List[] = {
      {&Version,        4,             1, U_LE},
      {NULL,            4,             1, U_LE},
      {PenData->Data,   PenData->Used, 1, U_XE},
      {Brush->Data,     Brush->Used,   1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PEN_OID, List);
   return(po);
}


/**
    \brief  Create and set a U_PMF_REGION PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Version    EmfPlusGraphicsVersion object
    \param  Count      Number of CHILD nodes.  This is one less than the total number of U_PMF_REGIONNODE objects in Nodes.
    \param  Nodes      U_PSEUDO_OBJ containing U_PMF_REGIONNODE object (Nodes defining region, may be a single element or a binary tree) 

    EMF+ manual 2.2.1.8, Microsoft name: EmfPlusRegion Object
*/
U_PSEUDO_OBJ *U_PMF_REGION_set(uint32_t Version, uint32_t Count, const U_PSEUDO_OBJ *Nodes){
   if(!Nodes || Nodes->Type  != U_PMF_REGIONNODE_OID)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Version,    4,           1, U_LE},
      {&Count,      4,           1, U_LE},
      {Nodes->Data, Nodes->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_REGION_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_STRINGFORMAT PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Sfs       pointer to U_PMF_STRINGFORMAT structure, with no variable part
    \param  Sfd       (optional) U_PSEUDO_OBJ containing U_PMF_STRINGFORMATDATA object

    EMF+ manual 2.2.1.9, Microsoft name: EmfPlusStringFormat Object
*/
U_PSEUDO_OBJ *U_PMF_STRINGFORMAT_set(U_PMF_STRINGFORMAT *Sfs, const U_PSEUDO_OBJ *Sfd){
   if(!Sfs){ return(NULL); }
   if(Sfd){
     if((!Sfs->TabStopCount && !Sfs->RangeCount) || (Sfd->Type  != U_PMF_STRINGFORMATDATA_OID))return(NULL);
   }
   else {
     if(Sfs->TabStopCount || Sfs->RangeCount)return(NULL);
   }
   const U_SERIAL_DESC List[] = {
      {&Sfs->Version,            4,                     1, U_LE},
      {&Sfs->Flags,              4,                     1, U_LE},
      {&Sfs->Language,           4,                     1, U_LE},
      {&Sfs->StringAlignment,    4,                     1, U_LE},
      {&Sfs->LineAlign,          4,                     1, U_LE},
      {&Sfs->DigitSubstitution,  4,                     1, U_LE},
      {&Sfs->DigitLanguage,      4,                     1, U_LE},
      {&Sfs->FirstTabOffset,     4,                     1, U_LE},
      {&Sfs->HotkeyPrefix,       4,                     1, U_LE},
      {&Sfs->LeadingMargin,      4,                     1, U_LE},
      {&Sfs->TrailingMargin,     4,                     1, U_LE},
      {&Sfs->Tracking,           4,                     1, U_LE},
      {&Sfs->Trimming,           4,                     1, U_LE},
      {&Sfs->TabStopCount,       4,                     1, U_LE},
      {&Sfs->RangeCount,         4,                     1, U_LE},
      {(Sfd ? Sfd->Data : NULL), (Sfd ? Sfd->Used : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_STRINGFORMAT_OID, List);
   return(po);
}

/**
    \brief  Create and set a PMF_4NUM PseudoObject (used for BrushID's)
    \return Pointer to PseudoObject, NULL on error
    \param  BrushID     U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
   
*/
U_PSEUDO_OBJ *U_PMF_4NUM_set(uint32_t BrushID){
   if(BrushID>63){ return(NULL); }
   const U_SERIAL_DESC List[] = {
      {&BrushID, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_4NUM_OID, List);
   return(po);
}

/**
    \brief Create and set a U_PMF_ARGB PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Alpha      Alpha       (0-255)
    \param  Red        Red   color (0-255)
    \param  Green      Green color (0-255)
    \param  Blue       Blue  color (0-255)

    EMF+ manual 2.2.2.1, Microsoft name: EmfPlusARGB Object
*/
U_PSEUDO_OBJ *U_PMF_ARGB_set(uint8_t Alpha, uint8_t Red, uint8_t Green, uint8_t Blue){
   const U_SERIAL_DESC List[] = {
      {&Blue,  1, 1, U_XE},
      {&Green, 1, 1, U_XE},
      {&Red,   1, 1, U_XE},
      {&Alpha, 1, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_ARGB_OID, List);
   return(po);
}

/**
    \brief Create and set an Array of U_PMF_ARGB valus in a PseudoObject
    \return Pointer to PseudoObject containing the count, followed by the array of colors, NULL on error
    \param  Count      Number of entries in Colors
    \param  Colors     Array of ARGB values

    EMF+ manual 2.2.2.1, Microsoft name: EmfPlusARGB Object
*/
U_PSEUDO_OBJ *U_PMF_ARGBN_set(uint32_t Count, U_PMF_ARGB *Colors){
   const U_SERIAL_DESC List[] = {
      {&Count, 4, 1,     U_LE},
      {Colors, 4, Count, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_ARGB_OID | U_PMF_ARRAY_OID, List);
   return(po);
}

/**
    \brief Set a U_PMF_ARGB object
    \return Object
    \param  Alpha      Alpha       (0-255)
    \param  Red        Red   color (0-255)
    \param  Green      Green color (0-255)
    \param  Blue       Blue  color (0-255)

    EMF+ manual 2.2.2.1, Microsoft name: EmfPlusARGB Object
*/
U_PMF_ARGB U_PMF_ARGBOBJ_set(uint8_t Alpha, uint8_t Red, uint8_t Green, uint8_t Blue){
   U_PMF_ARGB argb;
   char *ptr = (char *) &argb;
   U_PMF_MEMCPY_DSTSHIFT(&ptr, &Blue,  1);
   U_PMF_MEMCPY_DSTSHIFT(&ptr, &Green, 1);
   U_PMF_MEMCPY_DSTSHIFT(&ptr, &Red,   1);
   U_PMF_MEMCPY_DSTSHIFT(&ptr, &Alpha, 1);
   return(argb);
}

/**
    \brief  Create and set a U_PMF_BITMAP PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Bs       pointer to U_PMF_BITMAP structure, with no variable part
    \param  Bm       U_PSEUDO_OBJ containing an U_PMF_BITMAPDATA or U_PMF_COMPRESSEDIMAGE object 

    EMF+ manual 2.2.2.2, Microsoft name: EmfPlusBitmap Object
*/
U_PSEUDO_OBJ *U_PMF_BITMAP_set(const U_PMF_BITMAP *Bs, const U_PSEUDO_OBJ *Bm){
   if(!Bs)return(NULL);
   if(Bm->Type  != U_PMF_BITMAPDATA_OID &&
      Bm->Type  != U_PMF_COMPRESSEDIMAGE_OID )return(NULL);
   uint32_t Pad = UP4(Bm->Used) - Bm->Used;  /* undocumented padding, must be present for at least PNG */
   const U_SERIAL_DESC List[] = {
      {Bs,       4,               5,             U_LE},
      {Bm->Data, Bm->Used,        1,             U_XE},
      {NULL,     (Pad ? Pad : 0), (Pad ? 1 : 0), U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_BITMAP_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_BITMAPDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Ps     (optional) U_PSEUDO_OBJ containing a U_PMF_PALETTE structure
    \param  cbBm   Bytes in Bm
    \param  Bm     An array of bytes, meaning depends on fields in U_PMF_BITMAP object and the PixelFormat enumeration.

    EMF+ manual 2.2.2.3, Microsoft name: EmfPlusBitmapData Object
*/
U_PSEUDO_OBJ *U_PMF_BITMAPDATA_set( const U_PSEUDO_OBJ *Ps, int cbBm, const char *Bm){
   if(Ps && (Ps->Type  != U_PMF_PALETTE_OID))return(NULL);
   if(!Bm && cbBm)return(NULL);
   const U_SERIAL_DESC List[] = {
      {(Ps ? Ps->Data : NULL), (Ps  ? Ps->Used : 0), (Ps ? 1 : 0), U_LE},
      {Bm,                     cbBm,                 1,            U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_BITMAPDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_BLENDCOLORS PseudoObject
    \return Pointer to PseudoObject, NULL on Positions and Colors
    \param  Elements   number of elements in Positions, must agree with the number of Colors.
    \param  Positions  positions along gradient line. The first position MUST be 0.0 and the last MUST be 1.0.
    \param  Colors     U_PSEUDO_OBJ containing an array of U_PMF_ARGB objects: object colors at positions on gradient line

    EMF+ manual 2.2.2.4, Microsoft name: EmfPlusBlendColors Object
*/
U_PSEUDO_OBJ *U_PMF_BLENDCOLORS_set(uint32_t Elements, const U_FLOAT *Positions, const U_PSEUDO_OBJ *Colors){
   if(!Colors || !Positions || Colors->Type != (U_PMF_ARGB_OID | U_PMF_ARRAY_OID)){ return(NULL); }
   uint32_t CElements = (Colors->Used - 4)/4;
   if(CElements != Elements){ return(NULL); }
   const U_SERIAL_DESC List[] = {
      {&CElements,       4,                1,          U_LE},
      {Positions,        4,                CElements,  U_LE},
      {Colors->Data + 4, Colors->Used - 4, 1,          U_XE}, /* omit Elements part of this PseudoObject */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_BLENDCOLORS_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_BLENDCOLORS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Elements      members in osition, inluding Start and End (0.0 - 1.0)
    \param  StartColor    Start Color (U_PMF_ARGB)
    \param  EndColor      End Color (U_PMF_ARGB)

    EMF+ manual 2.2.2.5, Microsoft name: EmfPlusBlendFactors Object

    
    Positions always start at 0.0 and always end at 1.0.  It is not well documented but other
    start and end values generally do not work.
*/
U_PSEUDO_OBJ *U_PMF_BLENDCOLORS_linear_set(uint32_t Elements, U_PMF_ARGB StartColor, U_PMF_ARGB EndColor){
   double dP,dR,dG,dB,dA,P,R,G,B,A;
   U_FLOAT  StartPos = 0.0;
   U_FLOAT  EndPos = 1.0;
   U_FLOAT *Positions;
   U_FLOAT *pP;
   U_PMF_ARGB *Colors;
   U_PMF_ARGB *pC;
   unsigned int i;
   if(Elements <= 2 ){ return(NULL); }
   pP = Positions = (U_FLOAT *)malloc(Elements *sizeof(U_FLOAT));
   if(!Positions){ return(NULL); }
   pC = Colors    = (U_PMF_ARGB *)malloc(Elements *sizeof(U_PMF_ARGB));
   if(!Colors){
      free(Positions); 
      return(NULL);
   }
   dP = (EndPos    - StartPos   )/(float)(Elements - 1);
   dB = ((double)EndColor.Blue  - (double)StartColor.Blue )/(double)(Elements - 1);
   dG = ((double)EndColor.Green - (double)StartColor.Green)/(double)(Elements - 1);
   dR = ((double)EndColor.Red   - (double)StartColor.Red  )/(double)(Elements - 1);
   dA = ((double)EndColor.Alpha - (double)StartColor.Alpha)/(double)(Elements - 1);
   P  = StartPos;
   B  = StartColor.Blue; 
   G  = StartColor.Green; 
   R  = StartColor.Red; 
   A  = StartColor.Alpha; 
   for(i=0;i<Elements;i++,pC++,pP++){ /* hopefully the rounding errors are not a problem, used doubles to minimize that */
      *pP  = P;  
      P   += dP;
      *pC  = (U_PMF_ARGB){B,G,R,A};
      B   += dB;
      G   += dG;
      R   += dR;
      A   += dA;
   }
   U_PSEUDO_OBJ *poColors = U_PMF_ARGBN_set(Elements, Colors);
   U_PSEUDO_OBJ *po = U_PMF_BLENDCOLORS_set(Elements, Positions, poColors);
   U_PO_free(&poColors);
   free(Positions);
   free(Colors);
   return(po);
}


/**
    \brief  Create and set a U_PMF_BLENDFACTORS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Elements   members in each array
    \param  Positions  positions along gradient line.  The first position MUST be 0.0 and the last MUST be 1.0.
    \param  Factors    blending factors, 0.0->1.0 values, inclusive

    EMF+ manual 2.2.2.5, Microsoft name: EmfPlusBlendFactors Object
*/
U_PSEUDO_OBJ *U_PMF_BLENDFACTORS_set(uint32_t Elements, const U_FLOAT *Positions, const U_FLOAT *Factors){
   if(!Positions || !Factors)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Elements, 4, 1,        U_LE},
      {Positions, 4, Elements, U_LE},
      {Factors,   4, Elements, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_BLENDFACTORS_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_BLENDFACTORS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Elements      members in osition, inluding Start and End (0.0 - 1.0)
    \param  StartFactor   Start Factor (0.0 - 1.0)
    \param  EndFactor     End Factor (0.0 - 1.0)

    EMF+ manual 2.2.2.5, Microsoft name: EmfPlusBlendFactors Object

    
    Positions always start at 0.0 and always end at 1.0.  It is not well documented but other
    start and end values generally do not work.
*/
U_PSEUDO_OBJ *U_PMF_BLENDFACTORS_linear_set(uint32_t Elements, U_FLOAT StartFactor, U_FLOAT EndFactor){
   double dP,dF,P,F;
   U_FLOAT  StartPos = 0.0;
   U_FLOAT  EndPos = 1.0;
   U_FLOAT *Positions;
   U_FLOAT *Factors;
   U_FLOAT *pP;
   U_FLOAT *pF;
   unsigned int i;
   if(Elements <= 2 ){ return(NULL); }
   pP = Positions = (U_FLOAT *)malloc(Elements *sizeof(U_FLOAT));
   if(!Positions){ return(NULL); }
   pF = Factors   = (U_FLOAT *)malloc(Elements *sizeof(U_FLOAT));
   if(!Factors){
      free(Positions); 
      return(NULL);
   }
   dP = (EndPos    - StartPos   )/(float)(Elements - 1);
   dF = (EndFactor - StartFactor)/(float)(Elements - 1);
   P  = StartPos;
   F  = StartFactor;
   for(i=0;i<Elements;i++){ /* hopefully the rounding errors are not a problem, used doubles to minimize that */
      *pP++ = P;  P += dP;
      *pF++ = F;  F += dF;
   }
   U_PSEUDO_OBJ *po = U_PMF_BLENDFACTORS_set(Elements, Positions, Factors);
   free(Positions);
   free(Factors);
   return(po);
}

/**
    \brief  Create and set a U_PMF_BOUNDARYPATHDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Path       U_PSEUDO_OBJ containing U_PMF_PATH object

    EMF+ manual 2.2.2.6, Microsoft name: EmfPlusBoundaryPathData Object
*/
U_PSEUDO_OBJ *U_PMF_BOUNDARYPATHDATA_set(const U_PSEUDO_OBJ *Path){
   if(!Path || Path->Type  != U_PMF_PATH_OID)return(NULL);
   /* PO Used is size_t, might be 8 bytes, value in record must be 4 bytes */
   uint32_t Used = Path->Used;
   const U_SERIAL_DESC List[] = {
      {&Used,      4,          1, U_LE},
      {Path->Data, Path->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_BOUNDARYPATHDATA_OID, List);
   return(po);
}


/**
    \brief  Create and set a U_PMF_BOUNDARYPOINTDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Elements   members in each array
    \param  Points     array of U_PMF_POINTF

    EMF+ manual 2.2.2.7, Microsoft name: EmfPlusBoundaryPointData Object
*/
U_PSEUDO_OBJ *U_PMF_BOUNDARYPOINTDATA_set(uint32_t Elements, const U_PMF_POINTF *Points){
   if(!Points)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Elements, 4, 1,         U_LE},
      {Points,    4, 2*Elements,U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_BOUNDARYPOINTDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_CHARACTERRANGE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  First      First position in range
    \param  Length     Range length

    EMF+ manual 2.2.2.8, Microsoft name: EmfPlusCharacterRange Object
*/
U_PSEUDO_OBJ *U_PMF_CHARACTERRANGE_set(int32_t First, int32_t Length){
   const U_SERIAL_DESC List[] = {
      {&First,  4, 1, U_LE},
      {&Length, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_CHARACTERRANGE_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_COMPOUNDLINEDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Elements   Members in Widths
    \param  Widths     Array of U_FLOAT Line or gap widths (0.0 <-> 1.0, fraction of total line width )

    EMF+ manual 2.2.2.9, Microsoft name: EmfPlusCompoundLineData Object
*/
U_PSEUDO_OBJ *U_PMF_COMPOUNDLINEDATA_set(int32_t Elements, const char *Widths){
   if(!Widths)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Elements ,4, 1,       U_LE},
      {Widths,    4, Elements,U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_COMPOUNDLINEDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_COMPRESSEDIMAGE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  cbImage     Bytes in Image
    \param  Image       Stored image in one of the supported formats (GIF, PNG, etc.).

    EMF+ manual 2.2.2.10, Microsoft name: EmfPlusCompressedImage Object
*/
U_PSEUDO_OBJ *U_PMF_COMPRESSEDIMAGE_set(int32_t cbImage, const char *Image){
   if(!cbImage || !Image)return(NULL);
   const U_SERIAL_DESC List[] = {
      {Image,    cbImage, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_COMPRESSEDIMAGE_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_CUSTOMENDCAPDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Clc       U_PSEUDO_OBJ containing a U_PMF_CUSTOMLINECAP object

    EMF+ manual 2.2.2.11, Microsoft name: EmfPlusCustomEndCapData Object
*/
U_PSEUDO_OBJ *U_PMF_CUSTOMENDCAPDATA_set(const U_PSEUDO_OBJ *Clc){
   if(!Clc || Clc->Type  != U_PMF_CUSTOMLINECAP_OID)return(NULL);
   /* PO Used is size_t, might be 8 bytes, value in record must be 4 bytes */
   uint32_t Used = Clc->Used;
   const U_SERIAL_DESC List[] = {
      {&Used,      4,         1, U_LE},
      {Clc->Data,  Clc->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_CUSTOMENDCAPDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_CUSTOMLINECAPARROWDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Width       Arrow cap width (is multiplied by line width before draw)
    \param  Height      Arrow cap length (is multiplied by line width before draw)
    \param  MiddleInset Pixels between outer edge and filled region
    \param  FillState   If set, fill, otherwise, only border
    \param  StartCap    LineCap enumeration (type of cap)
    \param  EndCap      LineCap enumeration
    \param  Join        LineJoin enumeration
    \param  MiterLimit  Maximum (miter length / line width)
    \param  WidthScale  Scale for U_PMF_CUSTOMLINECAP object

    EMF+ manual 2.2.2.12, Microsoft name: EmfPlusCustomLineCapArrowData Object
*/
U_PSEUDO_OBJ *U_PMF_CUSTOMLINECAPARROWDATA_set(U_FLOAT Width, U_FLOAT Height, 
      U_FLOAT MiddleInset, uint32_t FillState, uint32_t StartCap, uint32_t EndCap, uint32_t Join,
      U_FLOAT MiterLimit, U_FLOAT WidthScale
   ){
   const U_SERIAL_DESC List[] = {
      {&Width,       4, 1, U_LE},
      {&Height      ,4, 1, U_LE},
      {&MiddleInset, 4, 1, U_LE},
      {&FillState,   4, 1, U_LE},
      {&StartCap,    4, 1, U_LE},
      {&EndCap,      4, 1, U_LE},
      {&Join,        4, 1, U_LE},
      {&MiterLimit,  4, 1, U_LE},
      {&WidthScale,  4, 1, U_LE},
      {NULL,         8, 2, U_LE}, /* FillHotSpots and LineHotSpots */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_CUSTOMLINECAPARROWDATA_OID, List);
   return(po);
}


/**
    \brief  Create and set a U_PMF_CUSTOMLINECAPDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Flags      CustomLineCapData flags
    \param  Cap        LineCap enumeration (type of cap)
    \param  Inset      Distance line cap start -> line end
    \param  StartCap   LineCap enumeration
    \param  EndCap     LineCap enumeration
    \param  Join       LineJoin enumeration
    \param  MiterLimit Maximum (miter length / line width)
    \param  WidthScale Scale for U_PMF_CUSTOMLINECAP object
    \param  Clcod      U_PSEUDO_OBJ containing a U_PMF_CUSTOMLINECAPOPTIONALDATA object

    EMF+ manual 2.2.2.13, Microsoft name: EmfPlusCustomLineCapData Object
*/
U_PSEUDO_OBJ *U_PMF_CUSTOMLINECAPDATA_set(uint32_t Flags, uint32_t Cap, 
      U_FLOAT Inset, uint32_t StartCap, uint32_t EndCap, 
      uint32_t Join, U_FLOAT MiterLimit, U_FLOAT WidthScale, 
      const U_PSEUDO_OBJ *Clcod
   ){
   if(!Clcod || Clcod->Type  != U_PMF_CUSTOMLINECAPOPTIONALDATA_OID)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Flags,      4,           1, U_LE},
      {&Cap,        4,           1, U_LE},
      {&Inset,      4,           1, U_LE},
      {&StartCap,   4,           1, U_LE},
      {&EndCap,     4,           1, U_LE},
      {&Join,       4,           1, U_LE},
      {&MiterLimit, 4,           1, U_LE},
      {&WidthScale, 4,           1, U_LE},
      {NULL,        8,           2, U_LE}, /* FillHotSpots and LineHotSpots */
      {Clcod->Data, Clcod->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_CUSTOMLINECAPDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_CUSTOMLINECAPOPTIONALDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Fill   U_PSEUDO_OBJ containing a U_PMF_FILLPATHOBJ object (optional)
    \param  Line   U_PSEUDO_OBJ containing a U_PMF_LINEPATH object (optional)

    EMF+ manual 2.2.2.14, Microsoft name: EmfPlusCustomLineCapOptionalData Object
*/
U_PSEUDO_OBJ *U_PMF_CUSTOMLINECAPOPTIONALDATA_set(const U_PSEUDO_OBJ *Fill, const U_PSEUDO_OBJ *Line){
   if(Fill && (Fill->Type  != U_PMF_FILLPATHOBJ_OID))return(NULL);
   if(Line && (Line->Type  != U_PMF_LINEPATH_OID))return(NULL);
   const U_SERIAL_DESC List[] = {
      {(Fill ? Fill->Data : NULL), (Fill ? Fill->Used : 0), 1, U_XE},
      {(Line ? Line->Data : NULL), (Line ? Line->Used : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_CUSTOMLINECAPOPTIONALDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_CUSTOMSTARTCAPDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Clc       U_PSEUDO_OBJ containing a U_PMF_CUSTOMLINECAPDATA object

    EMF+ manual 2.2.2.15, Microsoft name: EmfPlusCustomStartCapData Object
*/
U_PSEUDO_OBJ *U_PMF_CUSTOMSTARTCAPDATA_set(const U_PSEUDO_OBJ *Clc){
   if(!Clc || Clc->Type  != U_PMF_CUSTOMLINECAP_OID)return(NULL);
   const U_SERIAL_DESC List[] = {
      {Clc->Data, Clc->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_CUSTOMSTARTCAPDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_DASHEDLINEDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Elements   Members in Lengths
    \param  Lengths    Array of U_FLOAT holding lengths of dashes and spaces.

    EMF+ manual 2.2.2.16, Microsoft name: EmfPlusDashedLineData Object
*/
U_PSEUDO_OBJ *U_PMF_DASHEDLINEDATA_set(int32_t Elements, const U_FLOAT *Lengths){
   if(!Lengths)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Elements, 4, 1,        U_LE},
      {Lengths,   4, Elements, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_DASHEDLINEDATA_OID, List);
   return(po);
}

/**
    \brief  Utility function to create and set a U_PMF_DASHEDLINEDATA PseudoObject from one of a predefined set of patterns
    \return Pointer to PseudoObject, NULL on error
    \param  Unit       Length of the repeat unit
    \param  StdPat     Members in Lengths

    EMF+ manual 2.2.2.16, Microsoft name: EmfPlusDashedLineData Object
*/
U_PSEUDO_OBJ *U_PMF_DASHEDLINEDATA_set2(U_FLOAT Unit, int StdPat){
   uint32_t Elements;
   uint8_t *p;
   U_FLOAT SubUnit;
   U_FLOAT Lengths[8];  /* This is the most dash/spaces that will be needed*/
   int i;
   /* Dot = 1, Dash = 2; Long = 3, 0 = terminate pattern */
   uint8_t SB[U_DD_Types][5] =
      {
         {0,0,0,0,0},  // Solid                   
         {2,0,0,0,0},  // Dash 
         {2,2,0,0,0},  // DashDash
         {2,2,2,0,0},  // DashDashDash
         {2,2,2,2,0},  // DashDashDashDash
         {1,0,0,0,0},  // Dot  
         {1,1,0,0,0},  // DotDot 
         {1,1,1,0,0},  // DotDotDot
         {1,1,1,1,0},  // DotDotDotDot
         {2,1,0,0,0},  // DashDot
         {2,2,1,0,0},  // DashDashDot
         {2,2,1,1,0},  // DashDashDotDot
         {2,2,2,1,0},  // DashDashDashDot
         {2,1,1,0,0},  // DashDotDot
         {2,1,1,1,0},  // DashDotDotDot
         {2,1,2,1,0},  // DashDotDashDot
         {3,0,0,0,0},  // Long 
         {3,3,0,0,0},  // LongLong
         {3,3,3,0,0},  // LongLongLong
         {3,3,3,3,0},  // LongLongLongLong
         {3,1,0,0,0},  // LongDot
         {3,3,1,0,0},  // LongLongDot
         {3,3,1,1,0},  // LongLongDotDot
         {3,3,3,1,0},  // LongLongLongDot
         {3,1,1,0,0},  // LongDotDot
         {3,1,1,1,0},  // LongDotDotDot
         {3,1,3,1,0}   // LongDotLongDot
      };
   if(Unit <= 0                                      ){ return(NULL); }
   if((StdPat <= 0) || (StdPat > U_DD_LongDotLongDot)){ return(NULL); }
   p = &(SB[StdPat][0]);
   for(Elements = 0; *p; p++, Elements++){}
   SubUnit = Unit/((U_FLOAT) Elements);
   Elements *= 2;
   p = &(SB[StdPat][0]);
   for(i=0; *p; p++){
      switch(*p){
         case 0: break;
         case 1: /* dot */
           Lengths[i++] = SubUnit * 0.125;
           Lengths[i++] = SubUnit * 0.875;
           break;
         case 2: /* dash */
           Lengths[i++] = SubUnit * 0.5;
           Lengths[i++] = SubUnit * 0.5;
           break;
         case 3: /* long */
           Lengths[i++] = SubUnit * 0.75;
           Lengths[i++] = SubUnit * 0.25;
           break;
      }
   }

   U_PSEUDO_OBJ *po = U_PMF_DASHEDLINEDATA_set(Elements, Lengths);
   return(po);
}

/**
    \brief  Utility function to create and set a U_PMF_DASHEDLINEDATA PseudoObject from the bits that are set in a uint32_t
    \return Pointer to PseudoObject, NULL on error
    \param  Unit       Length of the repeat unit
    \param  BitPat     uint32_t holding the bit pattern, the lowest order bit MUST be set and the highest order MUST be clear.
    
    Make a line with a dot/dash pattern defined by the bits in the BitPat value.  If a bit is set it is drawn,
    if clear it is not.  Every bit drawn has length Unit/32, and consecutive drawn bits are merged together.  
    The lowest order bit is the first bit that may be drawn, the highest the last.  
    
        Example: if the integer has value 0x13 the pattern produced will be:
        0          ->  2*unit/32 drawn
        2*unit/32  ->  5*unit/32 not drawn
        5*unit/32  ->  6*unit/32 drawn
        6*unit/32  ->  unit      not drawn

    EMF+ manual 2.2.2.16, Microsoft name: EmfPlusDashedLineData Object
*/
U_PSEUDO_OBJ *U_PMF_DASHEDLINEDATA_set3(U_FLOAT Unit, uint32_t BitPat){
   uint32_t Elements=0;
   U_FLOAT SubUnit = Unit/32.0;
   U_FLOAT Lengths[32];  /* This is the most dash/spaces that will be needed*/
   if(!(0x00000001 & BitPat))return(NULL);  /* Pattern must start with a drawn segment, this bit must be set */
   if(  0x80000000 & BitPat )return(NULL);  /* Pattern must end with an undrawn segment, this bit must be clear */
   int i=0;
   int k;
   int lastType=1;
   int newType=0;
   uint32_t j=1;
   Lengths[0]=0;
   for(k=0; k<32; k++, j=j<<1){
      if(j & BitPat){
         if(!lastType){
            newType=1;
         }
      }
      else {
         if(lastType){
            newType=1;
         }
      }
      if(newType){
         i++;
         Lengths[i]=0;
         Elements++;
         lastType = !lastType;
         newType = 0;
      }
      Lengths[i] += SubUnit;
   }
   Elements = i+1;

   U_PSEUDO_OBJ *po = U_PMF_DASHEDLINEDATA_set(Elements, Lengths);
   return(po);
}

/**
    \brief  Create and set a U_PMF_FILLPATHOBJ PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Path       U_PSEUDO_OBJ containing a U_PMF_PATH object

    EMF+ manual 2.2.2.17, Microsoft name: EmfPlusFillPath Object
*/
U_PSEUDO_OBJ *U_PMF_FILLPATHOBJ_set(const U_PSEUDO_OBJ *Path){
   if(!Path || (Path->Type  != U_PMF_PATH_OID))return(NULL);
   const U_SERIAL_DESC List[] = {
      {Path->Data, Path->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_FILLPATHOBJ_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_FOCUSSCALEDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  ScaleX     value 0.0 <-> 1.0
    \param  ScaleY     value 0.0 <-> 1.0

    EMF+ manual 2.2.2.18, Microsoft name: EmfPlusFocusScaleData Object
*/
U_PSEUDO_OBJ *U_PMF_FOCUSSCALEDATA_set(U_FLOAT ScaleX, U_FLOAT ScaleY){
   uint32_t tmp = 2;
   const U_SERIAL_DESC List[] = {
      {&tmp,    4, 1, U_LE},
      {&ScaleX, 4, 1, U_LE},
      {&ScaleY, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_FOCUSSCALEDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_GRAPHICSVERSION object (Signature always set to 0xDBC01)
    \return Pointer to PseudoObject, NULL on error
    \param  GrfVersion GraphicsVersion enumeration

    EMF+ manual 2.2.2.19, Microsoft name: EmfPlusGraphicsVersion Object
*/
U_PSEUDO_OBJ *U_PMF_GRAPHICSVERSION_set(int GrfVersion){
   uint32_t tmp;
   tmp  = U_GFVR_PMF << 12; /* signature, can only have this value */
   tmp |= (GrfVersion & U_GFVR_MASKLO);
   const U_SERIAL_DESC List[] = {
      {&tmp, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_GRAPHICSVERSION_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_GRAPHICSVERSION object Structure (Signature always set to 0xDBC01)
    \return U_PMF_GRAPHICSVERSION
    \param  GrfVersion GraphicsVersion enumeration

    EMF+ manual 2.2.2.19, Microsoft name: EmfPlusGraphicsVersion Object
*/
U_PMF_GRAPHICSVERSION U_PMF_GRAPHICSVERSIONOBJ_set(int GrfVersion){
   uint32_t tmp;
   tmp  = U_GFVR_PMF << 12; /* signature, can only have this value */
   tmp |= (GrfVersion & U_GFVR_MASKLO);
   return(tmp);
}


/**
    \brief  Create and set a U_PMF_HATCHBRUSHDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Style      HatchStyle enumeration
    \param  Fg         U_PSEUDO_OBJ containing a U_ARGB object, Foreground hatch pattern line color
    \param  Bg         U_PSEUDO_OBJ containing a U_ARGB object, Background hatch pattern line color

    EMF+ manual 2.2.2.20, Microsoft name: EmfPlusHatchBrushData Object
*/
U_PSEUDO_OBJ *U_PMF_HATCHBRUSHDATA_set(uint32_t Style, const U_PSEUDO_OBJ *Fg, const U_PSEUDO_OBJ *Bg){
   if(!Fg ||(Fg->Type != U_PMF_ARGB_OID))return(NULL);
   if(!Bg ||(Bg->Type != U_PMF_ARGB_OID))return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Style,   4,        1, U_LE},
      {Fg->Data, Fg->Used, 1, U_XE},
      {Bg->Data, Bg->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_HATCHBRUSHDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_INTEGER7 PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Value 7 bit signed integer (stored in an integer, range 63 <-> -64, inclusive)

    EMF+ manual 2.2.2.21, Microsoft name: EmfPlusInteger7 Object
*/
U_PSEUDO_OBJ *U_PMF_INTEGER7_set(int Value){
   uint8_t utmp;
   if(Value < -64 || Value > 63)return(NULL);
   utmp = U_MASK_INT7 & *(unsigned int *)&Value;
   U_PSEUDO_OBJ *po =  U_PO_create((char *)&utmp, 1, 1, U_PMF_INTEGER7_OID); /* simple method is OK, no possibility of Endian issues */
   return(po);
}

/**
    \brief  Create and set a U_PMF_INTEGER15 PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Value 15 bit signed integer (stored in an integer, range 32677 <-> -32678, inclusive)

    EMF+ manual 2.2.2.22, Microsoft name: EmfPlusInteger15 Object
*/
U_PSEUDO_OBJ *U_PMF_INTEGER15_set(int Value){
   uint16_t utmp;
   if(Value < -32678 || Value > 32677)return(NULL);
   utmp = U_TEST_INT15 | (U_MASK_INT15 & *(unsigned int *)&Value);
   const U_SERIAL_DESC List[] = {
      {&utmp, 2, 1, U_BE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_INTEGER15_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_LANGUAGEIDENTIFIER value in 4 byte unsigned int, in NATIVE byte order
    \return LID value in least significant two bytes and 0 in most significant two bytes.
    \param  SubLId     Example: code for USA
    \param  PriLId     Example: code for English

    EMF+ manual 2.2.2.23, Microsoft name: EmfPlusLanguageIdentifier Object
*/
U_PMF_LANGUAGEIDENTIFIER U_PMF_LANGUAGEIDENTIFIEROBJ_set(int SubLId, int PriLId){
   U_PMF_LANGUAGEIDENTIFIER utmp32;
   utmp32 = ((SubLId & U_FF_MASK_SUBLID) << U_FF_SHFT_SUBLID) | ((PriLId & U_FF_MASK_PRILID) << U_FF_SHFT_PRILID);
   return(utmp32);
}

/**
    \brief  Create and set a U_PMF_LANGUAGEIDENTIFIER PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  LId       Language Identifier as produced by U_PMF_LANGUAGEIDENTIFIEROBJ_set().

    EMF+ manual 2.2.2.23, Microsoft name: EmfPlusLanguageIdentifier Object
*/
U_PSEUDO_OBJ *U_PMF_LANGUAGEIDENTIFIER_set(U_PMF_LANGUAGEIDENTIFIER LId){
   uint16_t utmp16;
   utmp16 = (LId & U_FF_MASK_LID) << U_FF_SHFT_LID;
   const U_SERIAL_DESC List[] = {
      {&utmp16, 2, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_LANGUAGEIDENTIFIER_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_LINEARGRADIENTBRUSHDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Lgbd       U_PMF_LINEARGRADIENTBRUSHDATA object (constant part)
    \param  Lgbod      U_PSEUDO_OBJ containing a U_PMF_LINEARGRADIENTBRUSHOPTIONALDATA object (variable part of a U_PMF_LINEARGRADIENTBRUSHDATA object)
     

    EMF+ manual 2.2.2.24, Microsoft name: EmfPlusLinearGradientBrushData Object
*/
U_PSEUDO_OBJ *U_PMF_LINEARGRADIENTBRUSHDATA_set(const U_PMF_LINEARGRADIENTBRUSHDATA *Lgbd, const U_PSEUDO_OBJ *Lgbod){
   if(!Lgbd || !Lgbod || (Lgbod->Type != U_PMF_LINEARGRADIENTBRUSHOPTIONALDATA_OID))return(NULL);
   const U_SERIAL_DESC List[] = {
      {Lgbd,                                4,           6, U_LE},
      {&(Lgbd->StartColor),                 4,           2, U_XE},
      {&(Lgbd->StartColor),                 4,           2, U_XE}, /* repeat the start/end colors.  Supposedly reserved. */
//    {NULL,                                4,           2, U_LE}, /* zero fill the two Reserved fields, no matter what is passed in */
      {(Lgbod->Used ? Lgbod->Data : NULL),  Lgbod->Used, 1, U_XE}, /* optional Data can exist and Used can be zero, SERIAL_set would throw an error on that */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_LINEARGRADIENTBRUSHDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_LINEARGRADIENTBRUSHOPTIONALDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Flags      Bits are set that indicate which of the following were included. The caller must clear before passing it in.
    \param  Tm         (optional) U_PSEUDO_OBJ containing a U_PMF_TRANSFORMMATRIX object
    \param  Bc         (optional) U_PSEUDO_OBJ containing a U_PMF_BLENDCOLORS object or NULL
    \param  BfH        (optional) U_PSEUDO_OBJ containing a U_PMF_BLENDFACTORS (H) object or NULL
    \param  BfV        (optional) U_PSEUDO_OBJ containing a U_PMF_BLENDFACTORS (V) object or NULL (WARNING, GDI+ defines this field but does not render it.  DO NOT USE.)
     

    EMF+ manual 2.2.2.25, Microsoft name: EmfPlusLinearGradientBrushOptionalData Object

    
    The rectangular gradients repeat in a tiled pattern.  Tm can rotate and offset the gradient within each tile.
    The gradient wraps when it is offset.
    
*/
U_PSEUDO_OBJ *U_PMF_LINEARGRADIENTBRUSHOPTIONALDATA_set(uint32_t *Flags, const U_PSEUDO_OBJ *Tm, 
      const U_PSEUDO_OBJ *Bc, const U_PSEUDO_OBJ *BfH, const U_PSEUDO_OBJ *BfV){
   if(!Flags                                         )return(NULL);
   if(Tm  && (Tm->Type  != U_PMF_TRANSFORMMATRIX_OID))return(NULL);
   if(Bc  && (Bc->Type  != U_PMF_BLENDCOLORS_OID)    )return(NULL);
   if(BfH && (BfH->Type != U_PMF_BLENDFACTORS_OID)   )return(NULL);
   if(BfV && (BfV->Type != U_PMF_BLENDFACTORS_OID)   )return(NULL);
   if(Bc  && (BfH || BfV)                            )return(NULL);
   const U_SERIAL_DESC List[] = {
      {(Tm  ? Tm->Data  : NULL), (Tm  ? Tm->Used  : 0), 1, U_XE},
      {(Bc  ? Bc->Data  : NULL), (Bc  ? Bc->Used  : 0), 1, U_XE},
      {(BfH ? BfH->Data : NULL), (BfH ? BfH->Used : 0), 1, U_XE},
      {(BfV ? BfV->Data : NULL), (BfV ? BfV->Used : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_LINEARGRADIENTBRUSHOPTIONALDATA_OID, List);
   if(Tm ){ *Flags |= U_BD_Transform;     }
   if(Bc ){ *Flags |= U_BD_PresetColors;  }
   if(BfH){ *Flags |= U_BD_BlendFactorsH; }
   if(BfV){ *Flags |= U_BD_BlendFactorsV; }
   return(po);
}

/**
    \brief  Create and set a U_PMF_LINEPATH PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Path      U_PSEUDO_OBJ containing a U_PMF_PATH object
     

    EMF+ manual 2.2.2.26, Microsoft name: EmfPlusLinePath Object
*/
U_PSEUDO_OBJ *U_PMF_LINEPATH_set(const U_PSEUDO_OBJ *Path){
   if(!Path || (Path->Type != U_PMF_PATH_OID))return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Path->Data, Path->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_LINEPATH_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_METAFILE object (NOT SUPPORTED!)
    \return Null
     

    EMF+ manual 2.2.2.27, Microsoft name: EmfPlusMetafile Object
*/
U_PSEUDO_OBJ *U_PMF_METAFILE_set(void){
   return(NULL);
}

/**
    \brief  Create and set a U_PMF_PALETTE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Flags      PaletteStyle flags
    \param  Elements   Members in Lengths
    \param  Pd         Array of U_PMF_ARGB holding colors of palettes. (Palette Data)

    EMF+ manual 2.2.2.28, Microsoft name: EmfPlusPalette Object
*/
U_PSEUDO_OBJ *U_PMF_PALETTE_set(uint32_t Flags, uint32_t Elements, const U_PMF_ARGB *Pd){
   if(!Pd)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Flags,    4, 1,        U_LE},
      {&Elements, 4, 1,        U_LE},
      {Pd,        4, Elements, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PALETTE_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_PATHGRADIENTBRUSHDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Flags        PaletteStyle flags
    \param  WrapMode     WrapMode enumeration
    \param  CenterColor  U_PMF_ARGB Center color
    \param  Center       Center coordinates
    \param  Gradient     U_PSEUDO_OBJ containing an Array of U_PMF_ARGB holding colors of Gradient
    \param  Boundary     U_PSEUDO_OBJ containing a U_PMF_BOUNDARYPATHDATA or U_PMF_BOUNDARYPOINTDATA object.  (Boundary Data)
    \param  Data         variable part of U_PMF_LINEARGRADIENTBRUSHDATA, exact composition depends on Flags

    EMF+ manual 2.2.2.29, Microsoft name: EmfPlusPathGradientBrushData Object
*/
U_PSEUDO_OBJ *U_PMF_PATHGRADIENTBRUSHDATA_set(uint32_t Flags, int32_t WrapMode, U_PMF_ARGB CenterColor, 
      U_PMF_POINTF Center,
      const U_PSEUDO_OBJ *Gradient, const U_PSEUDO_OBJ *Boundary, const U_PSEUDO_OBJ *Data){
   if( (Flags & U_BD_Path) && (!Boundary || (Boundary->Type != U_PMF_BOUNDARYPATHDATA_OID)))return(NULL);
   if(!(Flags & U_BD_Path) && (!Boundary || (Boundary->Type != U_PMF_BOUNDARYPOINTDATA_OID)))return(NULL);
   if(!Gradient || (Gradient->Type != (U_PMF_ARGB_OID | U_PMF_ARRAY_OID)))return(NULL);
   if(!(Flags & U_BD_Transform) && 
      !(Flags & U_BD_PresetColors) && 
      !(Flags & U_BD_BlendFactorsH) && 
      !(Flags & U_BD_FocusScales) && 
      (!Data || (Data->Type != U_PMF_PATHGRADIENTBRUSHOPTIONALDATA_OID)))return(NULL);

   const U_SERIAL_DESC List[] = {
      {&Flags,                         4,                       1, U_LE},
      {&WrapMode,                      4,                       1, U_LE},
      {&CenterColor,                   4,                       1, U_XE},
      {&Center.X,                      4,                       2, U_LE},
      {Gradient->Data,                 Gradient->Used,          1, U_XE}, /* includes Elements */
      {Boundary->Data,                 Boundary->Used,          1, U_XE},
      {(Data ? Data->Data : NULL),     (Data ? Data->Used : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PATHGRADIENTBRUSHDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_PATHGRADIENTBRUSHOPTIONALDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Flags        PaletteStyle flags
    \param  Tm           U_PSEUDO_OBJ containing a U_PMF_TRANSFORMMATRIX.  (Transformation matrix)
    \param  Pd           U_PSEUDO_OBJ containing a U_PMF_BLENDCOLORS or U_PMF_BLENDFACTORS object.  (Pattern Data)
    \param  Fsd          U_PSEUDO_OBJ containing a U_PMF_FOCUSSSCALEDATA object.  (Focus Scale Data)

    EMF+ manual 2.2.2.30, Microsoft name: EmfPlusPathGradientBrushOptionalData Object
*/
U_PSEUDO_OBJ *U_PMF_PATHGRADIENTBRUSHOPTIONALDATA_set(uint32_t Flags,
      const U_PSEUDO_OBJ *Tm, const U_PSEUDO_OBJ *Pd, const U_PSEUDO_OBJ *Fsd){
   if(Tm &&  (Tm->Type != U_PMF_TRANSFORMMATRIX_OID))return(NULL);
   if(Pd && !(Flags & (U_BD_PresetColors | U_BD_BlendFactorsH)))return(NULL);
   if( (Flags & U_BD_PresetColors)  && ((Flags & U_BD_BlendFactorsH)  || !Pd || (Pd->Type != U_PMF_BLENDCOLORS_OID) ))return(NULL);
   if( (Flags & U_BD_BlendFactorsH) && ((Flags & U_BD_PresetColors)   || !Pd || (Pd->Type != U_PMF_BLENDFACTORS_OID)))return(NULL);
   if(Fsd && !(Flags & U_BD_FocusScales))return(NULL);
   if( (Flags & U_BD_FocusScales)   && (!Fsd || (Fsd->Type != U_PMF_BLENDCOLORS_OID) ))return(NULL);
   const U_SERIAL_DESC List[] = {
      {(Tm  ? Tm->Data  : NULL), (Tm ?  Tm->Used  : 0), 1, U_XE},
      {(Pd  ? Pd->Data  : NULL), (Pd ?  Pd->Used  : 0), 1, U_XE},
      {(Fsd ? Fsd->Data : NULL), (Fsd ? Fsd->Used : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PATHGRADIENTBRUSHOPTIONALDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set an ARRAY of U_PMF_PATHPOINTTYPE objects
    \return Pointer to PseudoObject, NULL on error
    \param  Elements     Number of entries in Flags and Enumerations
    \param  Ppt          Array of unsigned bytes, lower 4 bits hold the PathPointType flag upper 4 bits hold the PathPointType enumeration.

    EMF+ manual 2.2.2.31, Microsoft name: EmfPlusPathPointType Object
*/
U_PSEUDO_OBJ *U_PMF_PATHPOINTTYPE_set(uint32_t Elements, const uint8_t *Ppt){
   if(!Elements || !Ppt)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Elements, 4, 1,        U_LE},
      {Ppt,       1, Elements, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PATHPOINTTYPE_OID | U_PMF_ARRAY_OID, List);
   return(po);
}

/**
    \brief  Create and set an ARRAY of U_PMF_PATHPOINTTYPE objects, with a preceding Elements count
    \return Pointer to PseudoObject, NULL on error
    \param  Elements Number of elements to add. First is added once and Others Elements-1 times.
    \param  First    Apply to first point,      unsigned byte, lower 4 bits hold the PathPointType flag upper 4 bits hold the PathPointType enumeration.
    \param  Others   Apply to all other points, unsigned byte, lower 4 bits hold the PathPointType flag upper 4 bits hold the PathPointType enumeration.

    EMF+ manual 2.2.2.31, Microsoft name: EmfPlusPathPointType Object
*/
U_PSEUDO_OBJ *U_PMF_PATHPOINTTYPE_set2(uint32_t Elements, uint8_t First, uint8_t Others){
   if(!Elements)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Elements,  4,   1,          U_XE},
      {&First,     1,   1,          U_XE},
      {&Others,    1,   Elements-1, U_RP},  /* replicate the one value N-1 times */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PATHPOINTTYPE_OID | U_PMF_ARRAY_OID, List);
   return(po);
}

/**
    \brief  Create and set an ARRAY of U_PMF_PATHPOINTTYPERLE objects
    \return Pointer to PseudoObject containing first the number of elements, then an array of U_PMF_PATHPOINTTYPERLE, NULL on error
    \param  Elements     Number of entries in the arrays
    \param  Bz           Array of unsigned bytes, if not zero, element has Bezier bit set
    \param  RL           Array of unsigned bytes, Run lengths.
    \param  Ppte         Array of unsigned bytes, PathPointType enumerations.

    EMF+ manual 2.2.2.32, Microsoft name: EmfPlusPathPointTypeRLE Object
*/
U_PSEUDO_OBJ *U_PMF_PATHPOINTTYPERLE_set(uint32_t Elements, const uint8_t *Bz, const uint8_t *RL, const uint8_t *Ppte){
   uint8_t utmp;
   if(!Bz || !RL || !Ppte)return(NULL);
   /* allocate space in the structure but put no data in */
   U_PSEUDO_OBJ *po =  U_PO_create(NULL, 4 + 2*Elements, 0, U_PMF_PATHPOINTTYPERLE_OID | U_PMF_ARRAY_OID);
   U_PSEUDO_OBJ *holdpo = po; 
   if(po){
      U_PSEUDO_OBJ *poi = U_PMF_4NUM_set(Elements);
      if(!poi)goto end;
      po = U_PO_append(po, poi->Data, poi->Used);   
      U_PO_free(&poi);
      if(!po)goto end;

      for( ;Elements; Elements--, Bz++, RL++, Ppte++){
         po = U_PO_append(po, (char *)Ppte, 1);
         if(!po)goto end;
         
         if(*RL > 0x3F) goto end; /* run length too big for field */
           
         utmp = (*Bz ? 1 : 0) | ((*RL & 0x3F)<<2); /* bit 1 is not used and is set to 0 */
         po = U_PO_append(po, (char *)&utmp, 1);
         if(!po)goto end;
      }
   }
end:
   if(!po)U_PO_free(&holdpo);
   return(holdpo);
}

/**
    \brief  Create and set a U_PMF_PENDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Unit      UnitType enumeration
    \param  Width     Width in units set by Unit
    \param  Pod       U_PSEUDO_OBJ containing first the PenData flags then a U_PMF_PENOPTIONALDATA object (the second part
                        may be an empty if Flags is 0)
     

    EMF+ manual 2.2.2.33, Microsoft name: EmfPlusPenData Object
*/
U_PSEUDO_OBJ *U_PMF_PENDATA_set(uint32_t Unit, U_FLOAT Width, const U_PSEUDO_OBJ *Pod){
   if(Pod && ((Pod->Type != U_PMF_PENOPTIONALDATA_OID) || Pod->Used < 4))return(NULL);
   const U_SERIAL_DESC List[] = {
      {(Pod ? Pod->Data : NULL),     4,                         1,             U_XE}, /* the Flags field, clear if no optional data */
      {&Unit,                        4,                         1,             U_LE},
      {&Width,                       4,                         1,             U_LE},
          /* next is the (optional) U_PMF_PENOPTIONALDATA part or a terminator */
      {(Pod ? Pod->Data + 4 : NULL), (Pod ? Pod->Used - 4 : 0), (Pod ? 1 : 0), (Pod ? U_XE : U_XX)},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PENDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_PENOPTIONALDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error.  Returned PO contains first the Flags, then the PO proper.
    \param  Flags           Determines which of the values are stored.
    \param  Tm              U_PSEUDO_OBJ containing a U_PMF_TRANSFORMMATRIX  object (Transformation matrix)
    \param  StartCap        LineCapType enumeration
    \param  EndCap          LineCapType enumeration
    \param  Join            LineJoinType enumeration
    \param  MiterLimit      Maximum (miter length / line width)
    \param  Style           LineStyle enumeration
    \param  DLCap           DashedLineCapType enumeration
    \param  DLOffset        Distance line start to first dash start
    \param  DLData          U_PSEUDO_OBJ containing a U_PMF_DASHEDLINEDATA  object     Dash and space widths
    \param  PenAlignment    PenAlignment enumeration
    \param  CmpndLineData   U_PSEUDO_OBJ containing a U_PMF_COMPOUNDLINEDATA object    Compount Line (parallel lines drawn instead of one)
    \param  CSCapData       U_PSEUDO_OBJ containing a U_PMF_CUSTOMSTARTCAPDATA object  Custom start cap  
    \param  CECapData       U_PSEUDO_OBJ containing a U_PMF_CUSTOMENDCAPDATA object    Custom end cap
     

    EMF+ manual 2.2.2.34, Microsoft name: EmfPlusPenOptionalData Object
*/
U_PSEUDO_OBJ *U_PMF_PENOPTIONALDATA_set(uint32_t Flags, U_PSEUDO_OBJ *Tm, int32_t StartCap, int32_t EndCap, uint32_t Join,
      U_FLOAT MiterLimit, int32_t Style, int32_t DLCap, U_FLOAT DLOffset, 
      U_PSEUDO_OBJ *DLData, int32_t PenAlignment, U_PSEUDO_OBJ *CmpndLineData, U_PSEUDO_OBJ *CSCapData, 
      U_PSEUDO_OBJ *CECapData
   ){

   if((Flags & U_PD_Transform)      && (!Tm            || (Tm->Type            != U_PMF_TRANSFORMMATRIX_OID))   )return(NULL);
   if((Flags & U_PD_DLData)         && (!DLData        || (DLData->Type        != U_PMF_DASHEDLINEDATA_OID))    )return(NULL);
   if((Flags & U_PD_CLData)         && (!CmpndLineData || (CmpndLineData->Type != U_PMF_COMPOUNDLINEDATA_OID))  )return(NULL);
   if((Flags & U_PD_CustomStartCap) && (!CSCapData     || (CSCapData->Type     != U_PMF_CUSTOMSTARTCAPDATA_OID)))return(NULL); 
   if((Flags & U_PD_CustomEndCap)   && (!CECapData     || (CECapData->Type     != U_PMF_CUSTOMENDCAPDATA_OID))  )return(NULL);
   
   /* prepend the Flags field to the PseudoObject proper */
   const U_SERIAL_DESC List[] = {
      {&Flags,                                                         4,                                                         1, U_LE},
      {((Flags & U_PD_Transform)      ? Tm->Data              : NULL), ((Flags & U_PD_Transform)      ? Tm->Used            : 0), 1, U_XE},
      {((Flags & U_PD_StartCap )      ? (char *)&StartCap     : NULL), ((Flags & U_PD_StartCap )      ? 4                   : 0), 1, U_LE},
      {((Flags & U_PD_EndCap )        ? (char *)&EndCap       : NULL), ((Flags & U_PD_EndCap )        ? 4                   : 0), 1, U_LE},
      {((Flags & U_PD_Join )          ? (char *)&Join         : NULL), ((Flags & U_PD_Join )          ? 4                   : 0), 1, U_LE},
      {((Flags & U_PD_MiterLimit )    ? (char *)&MiterLimit   : NULL), ((Flags & U_PD_MiterLimit )    ? 4                   : 0), 1, U_LE},
      {((Flags & U_PD_LineStyle )     ? (char *)&Style        : NULL), ((Flags & U_PD_LineStyle )     ? 4                   : 0), 1, U_LE},
      {((Flags & U_PD_DLCap )         ? (char *)&DLCap        : NULL), ((Flags & U_PD_DLCap )         ? 4                   : 0), 1, U_LE},
      {((Flags & U_PD_DLOffset )      ? (char *)&DLOffset     : NULL), ((Flags & U_PD_DLOffset )      ? 4                   : 0), 1, U_LE},
      {((Flags & U_PD_DLData )        ? DLData->Data          : NULL), ((Flags & U_PD_DLData )        ? DLData->Used        : 0), 1, U_XE},
      {((Flags & U_PD_NonCenter )     ? (char *)&PenAlignment : NULL), ((Flags & U_PD_NonCenter )     ? 4                   : 0), 1, U_LE},
      {((Flags & U_PD_CLData )        ? CmpndLineData->Data   : NULL), ((Flags & U_PD_CLData )        ? CmpndLineData->Used : 0), 1, U_XE},
      {((Flags & U_PD_CustomStartCap) ? CSCapData->Data       : NULL), ((Flags & U_PD_CustomStartCap) ? CSCapData->Used     : 0), 1, U_XE},
      {((Flags & U_PD_CustomEndCap )  ? CECapData->Data       : NULL), ((Flags & U_PD_CustomEndCap )  ? CECapData->Used     : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_PENOPTIONALDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set an ARRAY of U_PMF_POINT objects
    \return Pointer to PseudoObject, NULL on error
    \param  Elements     Number of pairs of points in Coords
    \param  Coords       Array of X,Y pairs.

    EMF+ manual 2.2.2.35, Microsoft name: EmfPlusPoint Object
*/
U_PSEUDO_OBJ *U_PMF_POINT_set(uint32_t Elements, const U_PMF_POINT *Coords){
   if(!Elements || !Coords)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Elements, 4, 1,          U_LE},
      { Coords,   2, 2*Elements, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_POINT_OID | U_PMF_ARRAY_OID, List);
   return(po);
}

/**
    \brief  Create and set an ARRAY of U_PMF_POINTF objects, with a leading Elements value
    \return Pointer to PseudoObject, NULL on error
    \param  Elements     Number of pairs of points in Coords
    \param  Coords       Array of X,Y pairs.

    EMF+ manual 2.2.2.36, Microsoft name: EmfPlusPointF Object
*/
U_PSEUDO_OBJ *U_PMF_POINTF_set(uint32_t Elements, const U_PMF_POINTF *Coords){
   if(!Elements || !Coords)return(NULL);
   const U_SERIAL_DESC List[] = {
      {&Elements, 4, 1,          U_LE},
      {Coords,    4, 2*Elements, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_POINTF_OID | U_PMF_ARRAY_OID, List);
   return(po);
}

/**
    \brief  Create and set an ARRAY of U_PMF_POINTR objects
    \return Pointer to PseudoObject, NULL on error
    \param  Elements     Number of pairs of points in Coords
    \param  Coords       Array of X,Y pairs.  These are absolute coordinates, they are converted to Relative here.

    EMF+ manual 2.2.2.37, Microsoft name: EmfPlusPointR Object
*/
U_PSEUDO_OBJ *U_PMF_POINTR_set(uint32_t Elements, const U_PMF_POINTF *Coords){
   int X,Y;
   U_FLOAT Xf,Yf;
   U_PSEUDO_OBJ *poi;
   /* Worst case scenario it is 4 bytes per coord, plus the count  */
   U_PSEUDO_OBJ *po =  U_PO_create(NULL, 4 + 4*Elements, 0, U_PMF_POINTR_OID); /* not exactly an array, so no U_PMF_ARRAY_OID */
   U_PSEUDO_OBJ *holdpo = po;
   if(!po)goto end;

   poi = U_PMF_4NUM_set(Elements);
   po = U_PO_append(po, poi->Data, poi->Used);      
   U_PO_free(&poi);
   if(!po)goto end;

   for(Xf = Yf = 0.0 ;Elements; Elements--, Coords++){
      Xf = U_ROUND(Coords->X) - Xf;
      Yf = U_ROUND(Coords->Y) - Yf;
      X = ( Xf >= UINT16_MAX ? UINT16_MAX : ( Xf <= INT16_MIN ? INT16_MIN : Xf));
      Y = ( Yf >= UINT16_MAX ? UINT16_MAX : ( Yf <= INT16_MIN ? INT16_MIN : Yf));
      Xf = U_ROUND(Coords->X);
      Yf = U_ROUND(Coords->Y);
      
      /* this is not a very efficient method, too much mucking around with memory */

      poi = U_PMF_INTEGER7_set(X);
      if(!poi)poi = U_PMF_INTEGER15_set(X); /* This one must work because of the range checking, above */
      po = U_PO_append(po, poi->Data, poi->Used);      
      U_PO_free(&poi);
      if(!po)goto end;

      poi = U_PMF_INTEGER7_set(Y);
      if(!poi)poi = U_PMF_INTEGER15_set(Y); /* This one must work because of the range checking, above */
      po = U_PO_append(po, poi->Data, poi->Used);      
      U_PO_free(&poi);
      if(!po)goto end;
   }
   /* Because the values stored were some unpredictable combination of 1 and 2 bytes, the last byte may not end
   on a 4 byte boundary.  Make it do so by padding with up to 3 zero bytes.  */

   int residual;
   residual = 3 & po->Used;
   if(residual){ 
      po = U_PO_append(po, NULL, (4 - residual));
      if(!po)goto end;     
   }

end:
   if(!po)U_PO_free(&holdpo);
   return(holdpo);
}

/**
    \brief  Create and set a U_PMF_RECT object
    \return Pointer to PseudoObject, NULL on error
    \param  X          UL X value
    \param  Y          UL Y value
    \param  Width      Width
    \param  Height     Height

    EMF+ manual 2.2.2.38, Microsoft name: EmfPlusRect Object
*/
U_PSEUDO_OBJ *U_PMF_RECT4_set(int16_t X, int16_t Y, int16_t Width, int16_t Height){
   const U_SERIAL_DESC List[] = {
      {&X,      2, 1, U_LE},
      {&Y,      2, 1, U_LE},
      {&Width,  2, 1, U_LE},
      {&Height, 2, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_RECT_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_RECT object
    \return Pointer to PseudoObject, NULL on error
    \param  Rect       U_PMF_RECT structures

    EMF+ manual 2.2.2.38, Microsoft name: EmfPlusRect Object
*/
U_PSEUDO_OBJ *U_PMF_RECT_set(U_PMF_RECT *Rect){
   const U_SERIAL_DESC List[] = {
      {Rect, 2, 4, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_RECT_OID, List);
   return(po);
}

/**
    \brief  Create and set an array of U_PMF_RECT objects in a PseudoObject
    \return Pointer to PseudoObject, NULL on error.  PseudoObject contains Elements followed by the array of U_PMF_RECT objects.
    \param  Elements   Number of elements in Rects
    \param  Rects      Array of U_PMF_RECT structures

    EMF+ manual 2.2.2.38, Microsoft name: EmfPlusRect Object
*/
U_PSEUDO_OBJ *U_PMF_RECTN_set(uint32_t Elements, U_PMF_RECT *Rects){
   if(!Rects){ return(NULL); }
   uint32_t count = Elements;
   U_SERIAL_DESC *List = (U_SERIAL_DESC *) malloc((Elements + 2) * sizeof(U_SERIAL_DESC));
   U_SERIAL_DESC *Lptr = List;
   if(!List){ return(NULL); }
   *Lptr++ = (U_SERIAL_DESC){&Elements, 4, 1, U_LE};
   for(; count; count--, Lptr++, Rects++){
      *Lptr = (U_SERIAL_DESC){Rects, 2, 4, U_LE};
   }
   *Lptr = (U_SERIAL_DESC){NULL,0,0,U_XX};
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_RECT_OID | U_PMF_ARRAY_OID, List);
   free(List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_RECTF object in a PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  X          UL X value
    \param  Y          UL Y value
    \param  Width      Width
    \param  Height     Height

    EMF+ manual 2.2.2.39, Microsoft name: EmfPlusRectF Object
*/
U_PSEUDO_OBJ *U_PMF_RECTF4_set(U_FLOAT X, U_FLOAT Y, U_FLOAT Width, U_FLOAT Height){
   const U_SERIAL_DESC List[] = {
      {&X,      4, 1, U_LE},
      {&Y,      4, 1, U_LE},
      {&Width,  4, 1, U_LE},
      {&Height, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_RECTF_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_RECTF object in a PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Rect      U_PMF_RECTF structure

    EMF+ manual 2.2.2.39, Microsoft name: EmfPlusRectF Object
*/
U_PSEUDO_OBJ *U_PMF_RECTF_set(U_PMF_RECTF *Rect){
   const U_SERIAL_DESC List[] = {
      {Rect,    4, 4, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_RECTF_OID, List);
   return(po);
}

/**
    \brief  Create and set an array of U_PMF_RECTF objects in a PseudoObject
    \return Pointer to PseudoObject, NULL on error.  PseudoObject contains Elements followed by the array of U_PMF_RECTF objects.
    \param  Elements   Number of elements in Rects
    \param  Rects      Array of U_PMF_RECTF structures

    EMF+ manual 2.2.2.39, Microsoft name: EmfPlusRectF Object
*/
U_PSEUDO_OBJ *U_PMF_RECTFN_set(uint32_t Elements, U_PMF_RECTF *Rects){
   if(!Rects){ return(NULL); }
   uint32_t count = Elements;
   U_SERIAL_DESC *List = (U_SERIAL_DESC *) malloc((Elements + 2) * sizeof(U_SERIAL_DESC));
   U_SERIAL_DESC *Lptr = List;
   if(!List){ return(NULL); }
   *Lptr++ = (U_SERIAL_DESC){&Elements, 4, 1, U_LE};
   for(; count; count--, Lptr++, Rects++){
     *Lptr = (U_SERIAL_DESC){Rects, 4, 4, U_LE}; 
   }
   *Lptr = (U_SERIAL_DESC){NULL,0,0,U_XX};
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_RECTF_OID | U_PMF_ARRAY_OID, List);
   free(List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_REGIONNODE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Type      RegionNodeDataType Enumeration
    \param  Rnd       (optional) U_PSEUDO_OBJ containing a U_PMF_REGIONNODEPATH, U_PMF_RECTF, or U_PMF_REGIONNODECHILDNODES object (Region Node Data)
     

    EMF+ manual 2.2.2.40, Microsoft name: EmfPlusRegionNode Object
*/
U_PSEUDO_OBJ *U_PMF_REGIONNODE_set(int32_t Type, const U_PSEUDO_OBJ *Rnd){
   int32_t pType;
   /* make sure that the type of Rnd agrees with Type */
   if(Rnd){
      pType = U_OID_To_RNDT(Rnd->Type);
      if( pType <  0){                     return(NULL); }
      if((pType >  0) && (pType != Type)){ return(NULL); }
      if((pType == 0) && 
         (
            (Type < U_RNDT_And) || 
            (Type > U_RNDT_Complement)
         )
      ){                                   return(NULL); }
      if((Type == U_RNDT_Rect) && (Rnd->Type != U_PMF_RECTF_OID)){           return(NULL); }
      if((Type == U_RNDT_Path) && (Rnd->Type != U_PMF_REGIONNODEPATH_OID)){  return(NULL); }
      
   }
   else {  /* only U_RNDT_Empty and  U_RNDT_Infinite do not have data */
      if((Type != U_RNDT_Empty)  || 
         (Type != U_RNDT_Infinite)  ){     return(NULL); }
   }
   

   const U_SERIAL_DESC List[] = {
      {&Type,                    4,                     1, U_LE},
      {(Rnd ? Rnd->Data : NULL), (Rnd ? Rnd->Used : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_REGIONNODE_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_REGIONNODECHILDNODES PseudoObject
    \return Pointer to PseudoObject containing a U_PMF_REGIONNODECHILDNODES_OID object, NULL on error
    \param  Left      U_PSEUDO_OBJ containing a U_PMF_REGIONNODE object
    \param  Right     U_PSEUDO_OBJ containing a U_PMF_REGIONNODE object
     

    EMF+ manual 2.2.2.41, Microsoft name: EmfPlusRegionNodeChildNodes Object
*/
U_PSEUDO_OBJ *U_PMF_REGIONNODECHILDNODES_set(const U_PSEUDO_OBJ *Left, const U_PSEUDO_OBJ *Right){
   if(!Left  || (Left->Type  != U_PMF_REGIONNODE_OID)){ return(NULL); }
   if(!Right || (Right->Type != U_PMF_REGIONNODE_OID)){ return(NULL); }

   const U_SERIAL_DESC List[] = {
      {Left->Data,  Left->Used,  1, U_XE},
      {Right->Data, Right->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_REGIONNODECHILDNODES_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_REGIONNODEPATH PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Path     U_PSEUDO_OBJ containing a U_PMF_PATH object
     

    EMF+ manual 2.2.2.42, Microsoft name: EmfPlusRegionNodePath Object
*/
U_PSEUDO_OBJ *U_PMF_REGIONNODEPATH_set(const U_PSEUDO_OBJ *Path){
   if(!Path  || (Path->Type  != U_PMF_PATH_OID)){ return(NULL); }
   /* PO Used is size_t, might be 8 bytes, value in record must be 4 bytes */
   uint32_t Used = Path->Used;

   const U_SERIAL_DESC List[] = {
      {&Used,      4,	       1, U_LE},
      {Path->Data, Path->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_REGIONNODEPATH_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_SOLIDBRUSHDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Color     U_PSEUDO_OBJ containing a U_PMF_ARGB object
     

    EMF+ manual 2.2.2.43, Microsoft name: EmfPlusSolidBrushData Object
*/
U_PSEUDO_OBJ *U_PMF_SOLIDBRUSHDATA_set(const U_PSEUDO_OBJ *Color){
   if(!Color || (Color->Type != U_PMF_ARGB_OID)){ return(NULL); }

   const U_SERIAL_DESC List[] = {
      {Color->Data, Color->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_SOLIDBRUSHDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_STRINGFORMATDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  TabStopCount  Entries in TabStop array
    \param  TabStops      (optional) Array of tabstop locations
    \param  Ranges        (optional) U_PSEUDO_OBJ containing an array of U_PMF_CHARACTERRANGE objects
     

    EMF+ manual 2.2.2.44, Microsoft name: EmfPlusStringFormatData Object
*/
U_PSEUDO_OBJ *U_PMF_STRINGFORMATDATA_set(uint32_t TabStopCount, U_FLOAT *TabStops, const U_PSEUDO_OBJ *Ranges){
   if(Ranges && (Ranges->Type  != (U_PMF_CHARACTERRANGE_OID | U_PMF_ARRAY_OID))){ return(NULL); }

   const U_SERIAL_DESC List[] = {
      {TabStops,                       TabStopCount*4,              1, U_LE},
      {(Ranges ? Ranges->Data : NULL), (Ranges ? Ranges->Used : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_STRINGFORMATDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_TEXTUREBRUSHDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Flags         BrushData flags
    \param  WrapMode      WrapMode enumeration
    \param  Tbod          U_PSEUDO_OBJ containing an U_PMF_TEXTUREBRUSHOPTIONALDATA object
     

    EMF+ manual 2.2.2.45, Microsoft name: EmfPlusTextureBrushData Object
*/
U_PSEUDO_OBJ *U_PMF_TEXTUREBRUSHDATA_set(uint32_t Flags, uint32_t WrapMode, const U_PSEUDO_OBJ *Tbod){
   if(Flags & ~U_BD_MASKB){ return(NULL); }  /* a bit was set that is not supported for this record */
   if(WrapMode > U_WM_Clamp){ return(NULL); }
   if(!Tbod || (Tbod->Type  != (U_PMF_TEXTUREBRUSHOPTIONALDATA_OID))){ return(NULL); }

   const U_SERIAL_DESC List[] = {
      {&Flags,     4,          1, U_LE},
      {&WrapMode,  4,          1, U_LE},
      {Tbod->Data, Tbod->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_TEXTUREBRUSHDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_TEXTUREBRUSHOPTIONALDATA PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Tm            (optional) U_PSEUDO_OBJ containing an U_PMF_TRANSFORMMATRIX object
    \param  Image         (optional) U_PSEUDO_OBJ containing an U_PMF_IMAGE object
     

    EMF+ manual 2.2.2.46, Microsoft name: EmfPlusTextureBrushOptionalData Object
*/
U_PSEUDO_OBJ *U_PMF_TEXTUREBRUSHOPTIONALDATA_set(const U_PSEUDO_OBJ *Tm, const U_PSEUDO_OBJ *Image){
   if(Tm    && (Tm->Type    != (U_PMF_TRANSFORMMATRIX_OID))){ return(NULL); }
   if(Image && (Image->Type != (U_PMF_IMAGE_OID))){           return(NULL); }

   const U_SERIAL_DESC List[] = {
      {(Tm ? Tm->Data : NULL),       (Tm ? Tm->Used : 0),       1, U_XE},
      {(Image ? Image->Data : NULL), (Image ? Image->Used : 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_TEXTUREBRUSHOPTIONALDATA_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_TRANSFORMMATRIX PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Tm            U_PMF_TRANSFORMMATRIX_ object
     

    EMF+ manual 2.2.2.47, Microsoft name: EmfPlusTransformMatrix Object
*/
U_PSEUDO_OBJ *U_PMF_TRANSFORMMATRIX_set(U_PMF_TRANSFORMMATRIX *Tm){
   if(!Tm){ return(NULL); }

   const U_SERIAL_DESC List[] = {
      {Tm, 4, 6, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_TRANSFORMMATRIX_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_BLUR PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Radius     Blur radius in pixels
    \param  ExpandEdge 1: expand bitmap by Radius; 0: bitmap size unchanged
     

    EMF+ manual 2.2.3.1, Microsoft name: BlurEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_BLUR_set(U_FLOAT Radius, uint32_t ExpandEdge){

   const U_SERIAL_DESC List[] = {
      {&Radius,     4, 1, U_LE},
      {&ExpandEdge, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_BLUR_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_BRIGHTNESSCONTRAST PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Brightness  -255 to 255, 0 is unchanged, positive increases, negative decreases
    \param  Contrast    -100 to 100, 0 is unchanged, positive increases, negative decreases
     

    EMF+ manual 2.2.3.2, Microsoft name: BrightnessContrastEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_BRIGHTNESSCONTRAST_set(int32_t Brightness, int32_t Contrast){

   const U_SERIAL_DESC List[] = {
      {&Brightness, 4, 1, U_LE},
      {&Contrast,   4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_BRIGHTNESSCONTRAST_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_COLORBALANCE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  CyanRed      -100 to 100, 0 is unchanged, positive increases Red   & decreases Cyan,    negative is opposite
    \param  MagentaGreen -100 to 100, 0 is unchanged, positive increases Green & decreases Magenta, negative is opposite
    \param  YellowBlue   -100 to 100, 0 is unchanged, positive increases Blue  & decreases Yellow,  negative is opposite
     

    EMF+ manual 2.2.3.3, Microsoft name: ColorBalanceEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_COLORBALANCE_set(int32_t CyanRed, int32_t MagentaGreen, int32_t YellowBlue){

   const U_SERIAL_DESC List[] = {
      {&CyanRed,      4, 1, U_LE},
      {&MagentaGreen, 4, 1, U_LE},
      {&YellowBlue,   4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_COLORBALANCE_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_COLORCURVE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Adjust       CurveAdjustment enumeration
    \param  Channel      CurveChannel enumeration
    \param  Intensity    adjustment to apply.  "Adjust" determines what field this is and range values.


    EMF+ manual 2.2.3.4, Microsoft name: ColorCurveEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_COLORCURVE_set(uint32_t Adjust, uint32_t Channel, int32_t Intensity){

   const U_SERIAL_DESC List[] = {
      {&Adjust,    4, 1, U_LE},
      {&Channel,   4, 1, U_LE},
      {&Intensity, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_COLORCURVE_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_COLORLOOKUPTABLE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  BLUT       Blue  color lookup table
    \param  GLUT       Green color lookup table
    \param  RLUT       Red   color lookup table
    \param  ALUT       Alpha color lookup table
    
     

    EMF+ manual 2.2.3.5, Microsoft name: ColorLookupTableEffect Object.
    All tables have 256 entries.
*/
U_PSEUDO_OBJ *U_PMF_IE_COLORLOOKUPTABLE_set(const uint8_t *BLUT, const uint8_t *GLUT, const uint8_t *RLUT, const uint8_t *ALUT){
   if(!BLUT || !GLUT || !RLUT || !ALUT)return(NULL);

   const U_SERIAL_DESC List[] = {
      {BLUT, 1, 256, U_XE},
      {GLUT, 1, 256, U_XE},
      {RLUT, 1, 256, U_XE},
      {ALUT, 1, 256, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_COLORLOOKUPTABLE_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_COLORMATRIX PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Matrix     5 x 5 color transformation matrix, First 4 rows are [{4 multiplier values},0.0] for R,G,B,A, last Row is [{4 color translation valuess}, 1.0]
     

    EMF+ manual 2.2.3.6, Microsoft name: ColorMatrixEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_COLORMATRIX_set(const U_FLOAT *Matrix){
   if(!Matrix)return(NULL);

   const U_SERIAL_DESC List[] = {
      {Matrix, 4, 25, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_COLORMATRIX_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_HUESATURATIONLIGHTNESS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Hue          -180 to 180, 0 is unchanged
    \param  Saturation   -100 to 100, 0 is unchanged
    \param  Lightness    -100 to 100, 0 is unchanged


    EMF+ manual 2.2.3.7, Microsoft name: HueSaturationLightnessEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_HUESATURATIONLIGHTNESS_set(int32_t Hue, int32_t Saturation, int32_t Lightness){

   const U_SERIAL_DESC List[] = {
      {&Hue,        4, 1, U_LE},
      {&Saturation, 4, 1, U_LE},
      {&Lightness,  4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_HUESATURATIONLIGHTNESS_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_LEVELS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Highlight      0 to 100, 100 is unchanged
    \param  Midtone     -100 to   0, 0 is unchanged
    \param  Shadow         0 to 100, 0 is unchanged


    EMF+ manual 2.2.3.8, Microsoft name: LevelsEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_LEVELS_set(int32_t Highlight, int32_t Midtone, int32_t Shadow){

   const U_SERIAL_DESC List[] = {
      {&Highlight, 4, 1, U_LE},
      {&Midtone,   4, 1, U_LE},
      {&Shadow,    4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_LEVELS_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_REDEYECORRECTION PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Elements   Number of members in Rects
    \param  Rects      Array of U_RECTL rectangular area(s) to apply red eye correction


    EMF+ manual 2.2.3.9, Microsoft name: RedEyeCorrectionEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_REDEYECORRECTION_set(uint32_t Elements, const U_RECTL *Rects){
   if(!Elements || !Rects){return(NULL);}

   const U_SERIAL_DESC List[] = {
      {&Elements, 4,   1,       U_LE},
      {Rects,     4*4, Elements,U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_REDEYECORRECTION_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_SHARPEN PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Radius     Sharpening radius in pixels
    \param  Sharpen    0 to 100, 0 is unchanged


    EMF+ manual 2.2.3.10, Microsoft name: SharpenEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_SHARPEN_set(U_FLOAT Radius, int32_t Sharpen){

   const U_SERIAL_DESC List[] = {
      {&Radius,  4, 1, U_LE},
      {&Sharpen, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_SHARPEN_OID, List);
   return(po);
}

/**
    \brief  Create and set a U_PMF_IE_TINT PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Hue         -180 to 180, [positive==clockwise] rotation in degrees starting from blue
    \param  Amount      -100 [add black] to 100[add white], 0 is unchanged.  Change in hue on specified axis


    EMF+ manual 2.2.3.11, Microsoft name: TintEffect Object
*/
U_PSEUDO_OBJ *U_PMF_IE_TINT_set(const int32_t Hue, const int32_t Amount){

   const U_SERIAL_DESC List[] = {
      {&Hue,    4, 1, U_LE},
      {&Amount, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMF_IE_TINT_OID, List);
   return(po);
}

//! \cond
/* internal routine, not part of the API.
   Returns a PseudoObject containing a U_PMR_CMN_HDR_OID object.
   The type is something like U_PMR_OFFSETCLIP (the record type, NOT the U_PMR_OFFSETCLIP_OID PseudoObject Type!). 
   The U_PMR_RECFLAG bit is added both in the data and in the Type of the PseudoObject.  
   If that bit is already set no harm, no foul.
*/

U_PSEUDO_OBJ *U_PMR_CMN_HDR_set(uint32_t Type, uint16_t Flags, uint32_t DataSize){

   uint32_t Size = 12 + UP4(DataSize); /* The header itself is always 12, PMR records must be a multiple of 4 */
   Type |= U_PMR_RECFLAG;
   uint16_t utmp16 = Type;
   const U_SERIAL_DESC List[] = {
      {&utmp16,   2, 1, U_LE},
      {&Flags,    2, 1, U_LE},    /* Microsoft EMF+ manual is BE, but this field in this implementation is  LE */
      {&Size,     4, 1, U_LE},
      {&DataSize, 4, 1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_CMN_HDR_OID, List);
   return(po);
}
//! \endcond


/**
    \brief  Create and set a U_PMR_STROKEFILLPATH PseudoObject
    \return Pointer to PseudoObject, NULL on error
    

    EMF+ manual mentioned in 2.1.1.1, not otherwise documented, Microsoft name: EmfPlusStrokeFillPath Record, Index 0x37
    
    "This record closes any open figures in a path, strokes the outline of 
     the path by using the current pen, and fills its interior by using the current brush."
     
*/
U_PSEUDO_OBJ *U_PMR_STROKEFILLPATH_set(void){
   int Size = 0;
   uint16_t utmp16 =  0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_STROKEFILLPATH,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_STROKEFILLPATH_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_OFFSETCLIP PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  dX          horizontal translation offset to apply to clipping region
    \param  dY          vertical   translation offset to apply to clipping region


    EMF+ manual 2.3.1.1, Microsoft name: EmfPlusOffsetClip Record,  Index 0x35
*/
U_PSEUDO_OBJ *U_PMR_OFFSETCLIP_set(U_FLOAT dX, U_FLOAT dY){
   int Size = 2*4;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_OFFSETCLIP,0,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&dX,      4,        1, U_LE},
      {&dY,      4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_OFFSETCLIP_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_RESETCLIP PseudoObject
    \return Pointer to PseudoObject, NULL on error


    EMF+ manual 2.3.1.2, Microsoft name: EmfPlusResetClip Record, Index 0x31
*/
U_PSEUDO_OBJ *U_PMR_RESETCLIP_set(void){
   int Size = 0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_RESETCLIP,0,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_RESETCLIP_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETCLIPPATH PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  CMenum      CombineMode enumeration..
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)


    EMF+ manual 2.3.1.3, Microsoft name: EmfPlusSetClipPath Record, Index 0x33
*/
U_PSEUDO_OBJ *U_PMR_SETCLIPPATH_set(uint32_t PathID, uint32_t CMenum){
   if(PathID>63)return(NULL);
   int Size=0;
   uint16_t utmp16 =  ((PathID & U_FF_MASK_OID8) << U_FF_SHFT_OID8) | ((CMenum & U_FF_MASK_CM4) << U_FF_SHFT_CM4);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETCLIPPATH,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETCLIPPATH_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETCLIPRECT PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  CMenum      CombineMode enumeration..
    \param  Rect        U_PSEUDO_OBJ containing an U_PMF_RECTF object or an array of U_PMF_RECTF objects (the first is used)
    

    EMF+ manual 2.3.1.4, Microsoft name: EmfPlusSetClipRect Record, Index 0x32
*/
U_PSEUDO_OBJ *U_PMR_SETCLIPRECT_set(uint32_t CMenum, const U_PSEUDO_OBJ *Rect){
   int Size=4*4;
   const char *start;
   uint16_t utmp16 = ((CMenum & U_FF_MASK_CM4) << U_FF_SHFT_CM4);
   if(Rect){
      if(        Rect->Type == U_PMF_RECTF_OID){ 
        start = Rect->Data;
      }
      else if(Rect->Type == (U_PMF_RECTF_OID | U_PMF_ARRAY_OID)){ 
        start = Rect->Data + 4;
      }
      else { return(0); }
   }
   else {    return(0); }

   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETCLIPRECT,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,  ph->Used, 1, U_XE},
      {start,     4,        4, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETCLIPRECT_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETCLIPREGION PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)
    \param  CMenum      CombineMode enumeration..
    

    EMF+ manual 2.3.1.5, Microsoft name: EmfPlusSetClipRegion Record, Index 0x34
*/
U_PSEUDO_OBJ *U_PMR_SETCLIPREGION_set(uint32_t PathID, uint32_t CMenum){
   if(PathID>63)return(NULL);
   int Size=0;
   uint16_t utmp16 =  ((PathID & U_FF_MASK_OID8) << U_FF_SHFT_OID8) | ((CMenum & U_FF_MASK_CM4) << U_FF_SHFT_CM4);

   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETCLIPREGION,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETCLIPREGION_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_COMMENT PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  cbData      Number of bytes in Data, must be a multiple of 4
    \param  Data        Private data, may be anything.  Stored in PseudoObject without adjusting byte order.
    

    EMF+ manual 2.3.2.1, Microsoft name: EmfPlusComment Record, Index 0x03
*/
U_PSEUDO_OBJ *U_PMR_COMMENT_set(size_t cbData, const void *Data){
   if(UP4(cbData) != cbData){ return(NULL); }
   if(cbData && !Data){       return(NULL); }
   int Size=cbData;

   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_COMMENT,0,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {Data,     cbData,   1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_COMMENT_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_ENDOFFILE PseudoObject
    \return Pointer to PseudoObject, NULL on error


    EMF+ manual 2.3.3.1, Microsoft name: EmfPlusEndOfFile Record, Index 0x02
*/
U_PSEUDO_OBJ *U_PMR_ENDOFFILE_set(void){
   int Size=0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_ENDOFFILE,0,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_ENDOFFILE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_GETDC PseudoObject
    \return Pointer to PseudoObject, NULL on error


    EMF+ manual 2.3.3.2, Microsoft name: EmfPlusGetDC Record, Index 0x04
*/
U_PSEUDO_OBJ *U_PMR_GETDC_set(void){
   int Size=0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_GETDC,0,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_GETDC_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_HEADER PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  IsDual       set = Dual-mode file, clear= EMF+ only file.
    \param  IsVideo      set = video device, clear= printer.  Ignore all other bits.
    \param  Version      U_PSEUDO_OBJ containing a U_PMF_GRAPHICSVERSION object
    \param  LogicalDpiX  Horizontal resolution reference device in DPI
    \param  LogicalDpiY  Vertical   resolution reference device in DPI
    

    EMF+ manual 2.3.3.3, Microsoft name: EmfPlusHeader Record, Index 0x01
*/
U_PSEUDO_OBJ *U_PMR_HEADER_set(int IsDual, int IsVideo, const U_PSEUDO_OBJ *Version, 
      uint32_t LogicalDpiX, uint32_t LogicalDpiY){
   if(!Version || (Version->Type != U_PMF_GRAPHICSVERSION_OID)){ return(NULL); }
   int Size=Version->Used + 3*4;
   uint16_t utmp16 =  (IsDual ? U_PPF_DM : 0);
   uint32_t Flags  =  (IsVideo ? U_PPF_VIDEO : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_HEADER,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {Version->Data, Version->Used, 1, U_XE},
      {&Flags,        4,             1, U_LE},
      {&LogicalDpiX,  4,             1, U_LE},
      {&LogicalDpiY,  4,             1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_HEADER_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_CLEAR PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Color        U_PSEUDO_OBJ containing a U_PMF_ARGB object.
    
   

    EMF+ manual 2.3.4.1, Microsoft name: EmfPlusClear Record, Index 0x09

    Erase everything preceding, set background ARGB to Color.
*/
U_PSEUDO_OBJ *U_PMR_CLEAR_set(const U_PSEUDO_OBJ *Color){
   if(!Color || (Color->Type != U_PMF_ARGB_OID)){ return(NULL); }
   int Size=Color->Used;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_CLEAR,0,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,    ph->Used,    1, U_XE},
      {Color->Data, Color->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_CLEAR_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWARC PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  Start       Start angle, >=0.0, degrees clockwise from 3:00
    \param  Sweep       Sweep angle, -360<= angle <=360, degrees clockwise from Start
    \param  Rect        U_PSEUDO_OBJ containing a U_PMF_RECT or U_PMF_RECTF object
   

    EMF+ manual 2.3.4.2, Microsoft name: EmfPlusDrawArc Record, Index 0x12
*/
U_PSEUDO_OBJ *U_PMR_DRAWARC_set(uint32_t PenID, U_FLOAT Start, U_FLOAT Sweep, const U_PSEUDO_OBJ *Rect){
   int ctype;
   if(PenID>63)return(NULL);
   if(!Rect){                                 return(NULL); }
   else {
      if(     Rect->Type == U_PMF_RECT_OID ){ ctype = 1;    }
      else if(Rect->Type == U_PMF_RECTF_OID){ ctype = 0;    }
      else {                                  return(NULL); }
   }
   int Size = 2*4 + Rect->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) | (PenID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWARC,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,   ph->Used,   1, U_XE},
      {&Start,     4,          1, U_LE},
      {&Sweep,     4,          1, U_LE},
      {Rect->Data, Rect->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWARC_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWBEZIERS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  Points      U_PSEUDO_OBJ containing first Elements, then a U_PMF_POINT, U_PMF_POINTR or U_PMF_POINTF object
   

    EMF+ manual 2.3.4.3, Microsoft name: EmfPlusDrawBeziers Record, Index 0x19
*/
U_PSEUDO_OBJ *U_PMR_DRAWBEZIERS_set(uint32_t PenID, const U_PSEUDO_OBJ *Points){
   int ctype, RelAbs;
   if(PenID>63)return(NULL);
   if(Points){
      if(     Points->Type == U_PMF_POINTR_OID){                     RelAbs = 1; ctype = 0; }
      else if(Points->Type == (U_PMF_POINT_OID  | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 1; }
      else if(Points->Type == (U_PMF_POINTF_OID | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 0; }
      else {                                                         return(NULL);          }
   }
   else {                                                            return(NULL);          }
   int Size = Points->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) | (RelAbs ? U_PPF_P : 0) |(PenID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWBEZIERS,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,     ph->Used,     1, U_XE},
      {Points->Data, Points->Used, 1, U_XE}, /* Includes Elements */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWBEZIERS_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWCLOSEDCURVE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  Tension     Controls splines, 0 is straight line, >0 is curved
    \param  Points      U_PSEUDO_OBJ containing a U_PMF_POINT, U_PMF_POINTR or U_PMF_POINTF object
   

    EMF+ manual 2.3.4.4, Microsoft name: EmfPlusDrawClosedCurve Record, Index 0x17

    Curve is a cardinal spline.

    References sent by MS support:

       http://alvyray.com/Memos/CG/Pixar/spline77.pdf

       http://msdn.microsoft.com/en-us/library/4cf6we5y(v=vs.110).aspx


*/
U_PSEUDO_OBJ *U_PMR_DRAWCLOSEDCURVE_set(uint32_t PenID, U_FLOAT Tension, const U_PSEUDO_OBJ *Points){
   int ctype, RelAbs;
   if(PenID>63)return(NULL);
   if(Points){
      if(     Points->Type == U_PMF_POINTR_OID){                     RelAbs = 1; ctype = 0; }
      else if(Points->Type == (U_PMF_POINT_OID  | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 1; }
      else if(Points->Type == (U_PMF_POINTF_OID | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 0; }
      else {                                                         return(NULL);          }
   }
   else {                                                            return(NULL);          }
   int Size = 4 + Points->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) | (RelAbs ? U_PPF_P : 0) |(PenID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWCLOSEDCURVE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,     ph->Used,     1, U_XE},
      {&Tension,     4,            1, U_LE},
      {Points->Data, Points->Used, 1, U_XE}, /* includes Elements*/
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWCLOSEDCURVE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWCURVE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  Tension     Controls splines, 0 is straight line, >0 is curved
    \param  Offset      The starting point in the list of points, 0 is first.
    \param  NSegs       Number of segments to draw. Starting at Offset go NSegs straight lines, must not run out of points..
    \param  Points      U_PSEUDO_OBJ containing an element count then a series of U_PMF_POINT or U_PMF_POINTF object
   

    EMF+ manual 2.3.4.5, Microsoft name: EmfPlusDrawCurve Record, Index 0x18

    Curve is a cardinal spline, using doubled terminator points to generate curves for the terminal segments.

    References sent by MS support:

       http://alvyray.com/Memos/CG/Pixar/spline77.pdf

       http://msdn.microsoft.com/en-us/library/4cf6we5y(v=vs.110).aspx

*/
U_PSEUDO_OBJ *U_PMR_DRAWCURVE_set(uint32_t PenID, U_FLOAT Tension, uint32_t Offset, uint32_t NSegs, const U_PSEUDO_OBJ *Points){
   int ctype;
   if(PenID>63)return(NULL);
   if(!Points){                                                      return(NULL); }
   if(!NSegs){                                                       return(NULL); }
   else {
      if(     Points->Type == (U_PMF_POINT_OID  | U_PMF_ARRAY_OID)){ ctype = 1;    }
      else if(Points->Type == (U_PMF_POINTF_OID | U_PMF_ARRAY_OID)){ ctype = 0;    }
      else {                                                         return(NULL); }
   }
   uint32_t Elements = (Points->Used - 4)/(ctype ? 4 : 8);  /* This way do not need to worry about byte order */
   if(Offset + NSegs + 1 > Elements){   return(NULL); }
   int Size = 3*4 + Points->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) |(PenID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWCURVE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,         ph->Used,       1, U_XE},
      {&Tension,         4,              1, U_LE},
      {&Offset,          4,              1, U_LE},
      {&NSegs,           4,              1, U_LE},
      {Points->Data,     Points->Used,   1, U_XE}, /* Elements, points */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWCURVE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWDRIVERSTRING PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  FontID      U_PMF_FONT object in the EMF+ object table (0-63, inclusive)
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    \param  DSOFlags    DriverStringOptions flags
    \param  HasMatrix   If 1 record contains a TransformMatrix field, if 0 it does not.
    \param  GlyphCount  The number of Elements in Glyphs, must agree with the number of elements in Points.
    \param  Glyphs      If U_DSO_CmapLookup is set in DSOFlags this is an array of UTF16LE characters, otherwise, it is an array of indices into the U_PMF_FONT object indexed by Object_ID in flags.
    \param  Points      U_PSEUDO_OBJ containing a U_PMF_POINTF object
    \param  Tm          U_PSEUDO_OBJ containing a U_PMF_TRANSFORMMATRIX object. Apply to Glyphs & Positions. Present if HasMatrix is 1
   

    EMF+ manual 2.3.4.6, Microsoft name: EmfPlusDrawDriverString Record, Index 0x36
*/
U_PSEUDO_OBJ *U_PMR_DRAWDRIVERSTRING_set(uint32_t FontID, const U_PSEUDO_OBJ *BrushID, 
      uint32_t DSOFlags, uint32_t HasMatrix, uint32_t GlyphCount,
      const uint16_t *Glyphs, const U_PSEUDO_OBJ *Points, const U_PSEUDO_OBJ *Tm){
   int btype;
   if(FontID>63){                                                           return(NULL); }
   if(!Glyphs){                                                             return(NULL); }
   if(!Points || (Points->Type != (U_PMF_POINTF_OID | U_PMF_ARRAY_OID))){   return(NULL); }
   uint32_t Elements = (Points->Used -4)/4;
   if(GlyphCount != Elements){                                              return(NULL); } 
   if(BrushID){ 
      if(      BrushID->Used != 4){                                         return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){                            btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){                            btype = 0;    }
      else {                                                                return(NULL); }
   }
   else {                                                                   return(NULL); } 
   int Size = 4 + BrushID->Used + 3*4 + Elements*2 + (Points->Used - 4);
   if(HasMatrix){
      if(!Tm){                                                              return(NULL); }
      else if(Tm->Type != (U_PMF_TRANSFORMMATRIX_OID)){                     return(NULL); }
      Size += Tm->Used;
   }
   uint16_t utmp16 =  (btype ? U_PPF_B : 0) |(FontID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWDRIVERSTRING,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,ph->Used, 1, U_XE},
      {BrushID->Data,                  BrushID->Used,              1,        U_XE},
      {&DSOFlags,                      4,                          1,        U_LE},
      {&HasMatrix,                     4,                          1,        U_LE},
      {&Elements,                      4,                          1,        U_LE},
      {Glyphs,                         2,                          Elements, U_LE},
      {Points->Data + 4,               Points->Used - 4,           1,        U_XE},  /* omit Elements */
      {(HasMatrix ? Tm->Data : NULL),  (HasMatrix ? Tm->Used : 0), 1,        U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWDRIVERSTRING_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWELLIPSE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  Rect        U_PSEUDO_OBJ containing a U_PMF_RECT or U_PMF_RECTF object
   

    EMF+ manual 2.3.4.7, Microsoft name: EmfPlusDrawEllipse Record, Index 0x0F
*/
U_PSEUDO_OBJ *U_PMR_DRAWELLIPSE_set(uint32_t PenID, const U_PSEUDO_OBJ *Rect){
   if(PenID>63)return(NULL);
   int ctype;
   if(!Rect){                                 return(NULL); }
   else {
      if(     Rect->Type == U_PMF_RECT_OID ){ ctype = 1;    }
      else if(Rect->Type == U_PMF_RECTF_OID){ ctype = 0;    }
      else {                                  return(NULL); }
   }
   int Size = Rect->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) | (PenID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWELLIPSE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,   ph->Used,   1, U_XE},
      {Rect->Data, Rect->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWELLIPSE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWIMAGE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  ImgID       U_PMF_IMAGE object in the EMF+ object table (0-63, inclusive)
    \param  ImgAttrID   index of a U_PMF_IMAGEATTRIBUTES object in the object table
    \param  SrcUnit     UnitType enumeration
    \param  SrcRect     U_PSEUDO_OBJ containing a U_PMF_RECTF object, Source region of image 
    \param  DstRect     U_PSEUDO_OBJ containing a U_PMF_RECT or U_PMF_RECTF object
   

    EMF+ manual 2.3.4.8, Microsoft name: EmfPlusDrawImage Record, Index 0x1A
*/
U_PSEUDO_OBJ *U_PMR_DRAWIMAGE_set(uint32_t ImgID,  
      int32_t ImgAttrID, int32_t SrcUnit, const U_PSEUDO_OBJ *SrcRect, const U_PSEUDO_OBJ *DstRect){
   int ctype;
   if(ImgID>63)return(NULL);
   if(!SrcRect || (SrcRect->Type != U_PMF_RECTF_OID)){  return(NULL); }
   if(!DstRect){                                 return(NULL); }
   else {
      if(     DstRect->Type == U_PMF_RECT_OID ){ ctype = 1;    }
      else if(DstRect->Type == U_PMF_RECTF_OID){ ctype = 0;    }
      else {                                     return(NULL); }
   }
   int Size = 2*4 + SrcRect->Used + DstRect->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) | (ImgID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWIMAGE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {&ImgAttrID,    4,             1, U_LE},
      {&SrcUnit,      4,             1, U_LE},
      {SrcRect->Data, SrcRect->Used, 1, U_XE},
      {DstRect->Data, DstRect->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWIMAGE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWIMAGEPOINTS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  ImgID       U_PMF_IMAGE object in the EMF+ object table (0-63, inclusive)
    \param  etype       Set: effect from previous U_PMR_SERIALIZABLEOBJECT record will be applied; Clear:  no effect applied
    \param  ImgAttrID   index of a U_PMF_IMAGEATTRIBUTES object in the object table
    \param  SrcUnit     UnitType enumeration
    \param  SrcRect     U_PSEUDO_OBJ containing a U_PMF_RECTF object, Source region of image 
    \param  Points      U_PSEUDO_OBJ containing an array of 3 (U_PMF_POINT, U_PMF_POINTF, or U_PMF_POINTF) objects. These points are the UL, UR, and LL vertices of a parallelogram.
   

    EMF+ manual 2.3.4.9, Microsoft name: EmfPlusDrawImagePoints Record, Index 0x1B


   WARNING!  Windows XP Preview does not show filter effects, whether or not U_PPF_E is set.   They are visible if the EMF+
   file is inserted as an image into PowerPoint.
*/
U_PSEUDO_OBJ *U_PMR_DRAWIMAGEPOINTS_set(uint32_t ImgID, int etype,
      int32_t ImgAttrID, int32_t SrcUnit, const U_PSEUDO_OBJ *SrcRect,
      const U_PSEUDO_OBJ *Points){
   int ctype, RelAbs;
   if(ImgID>63){                                                      return(NULL); }
   if(!SrcRect || (SrcRect->Type != U_PMF_RECTF_OID)){                return(NULL); }
   if(Points){
      if(     Points->Type == U_PMF_POINTR_OID){                     RelAbs = 1; ctype = 0; }
      else if(Points->Type == (U_PMF_POINT_OID  | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 1; }
      else if(Points->Type == (U_PMF_POINTF_OID | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 0; }
      else {                                                         return(NULL);          }
   }
   else {                                                            return(NULL);          }
   int Size = 2*4 + SrcRect->Used + Points->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) | (etype ? U_PPF_E : 0) | (RelAbs ? U_PPF_P : 0) | (ImgID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWIMAGEPOINTS,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {&ImgAttrID,    4,             1, U_LE},
      {&SrcUnit,      4,             1, U_LE},
      {SrcRect->Data, SrcRect->Used, 1, U_XE},
      {Points->Data,  Points->Used,  1, U_XE}, /* includes Elements*/
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWIMAGEPOINTS_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWLINES PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  dtype       Set: path must be closed, Clear: path is open
    \param  Points      U_PSEUDO_OBJ containing an array of 3 U_PMF_POINT, U_PMF_POINTR, or U_PMF_POINTF objects
   

    EMF+ manual 2.3.4.10, Microsoft name: EmfPlusDrawLines Record, Index 0x0D
*/
U_PSEUDO_OBJ *U_PMR_DRAWLINES_set(uint32_t PenID, int dtype, const U_PSEUDO_OBJ *Points){
   int ctype, RelAbs;
   if(PenID>63){                                                      return(NULL); }
   if(Points){
      if(     Points->Type == U_PMF_POINTR_OID){                     RelAbs = 1; ctype = 0; }
      else if(Points->Type == (U_PMF_POINT_OID  | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 1; }
      else if(Points->Type == (U_PMF_POINTF_OID | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 0; }
      else {                                                         return(NULL);          }
   }
   else {                                                            return(NULL);          }
   int Size = Points->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) | (dtype ? U_PPF_D : 0) | (RelAbs ? U_PPF_P : 0) | (PenID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWLINES,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,     ph->Used,     1, U_XE},
      {Points->Data, Points->Used, 1, U_XE}, /* includes Elements */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWLINES_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWPATH PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    

    EMF+ manual 2.3.4.11, Microsoft name: EmfPlusDrawPath Record, Index 0x15
*/
U_PSEUDO_OBJ *U_PMR_DRAWPATH_set(uint32_t PathID, uint32_t PenID){
   if(PathID>63)return(NULL);
   if(PenID>63)return(NULL);
   int Size = 4;
   uint16_t utmp16 =  (PathID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWPATH,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&PenID,   4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWPATH_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWPIE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  Start       Start angle, >=0.0, degrees clockwise from 3:00
    \param  Sweep       Sweep angle, -360<= angle <=360, degrees clockwise from Start
    \param  Rect        U_PSEUDO_OBJ containing a U_PMF_RECT or U_PMF_RECTF object
   

    EMF+ manual 2.3.4.12, Microsoft name: EmfPlusDrawPie Record, Index 0x0D
*/
U_PSEUDO_OBJ *U_PMR_DRAWPIE_set(uint32_t PenID, 
      U_FLOAT Start, U_FLOAT Sweep, const U_PSEUDO_OBJ *Rect){
   int ctype;
   if(PenID>63)return(NULL);
   if(!Rect){                                 return(NULL); }
   else {
      if(     Rect->Type == U_PMF_RECT_OID ){ ctype = 1;    }
      else if(Rect->Type == U_PMF_RECTF_OID){ ctype = 0;    }
      else {                                  return(NULL); }
   }
   int Size = 2*4 + Rect->Used;
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0) | (PenID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWPIE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,   ph->Used,   1, U_XE},
      {&Start,     4,          1, U_LE},
      {&Sweep,     4,          1, U_LE},
      {Rect->Data, Rect->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWPIE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWRECTS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  Rects       U_PSEUDO_OBJ containing 1 rect OR  a count N follwed by N rects.  Rects may be either U_PMF_RECT or U_PMF_RECTF
   

    EMF+ manual 2.3.4.13, Microsoft name: EmfPlusDrawRects Record, Index 0x0B
*/
U_PSEUDO_OBJ *U_PMR_DRAWRECTS_set(uint32_t PenID, const U_PSEUDO_OBJ *Rects){
   int ctype;
   int just1;
   uint32_t Elements=1; /* only used when a single rect is passed in, not an array, not even an array with one member*/
   if(PenID>63){ return(NULL); }
   if(Rects){
      if(      (Rects->Type & U_PMF_MASK_OID) == U_PMF_RECT_OID ){   ctype = 1;    }
      else if( (Rects->Type & U_PMF_MASK_OID) == U_PMF_RECTF_OID){   ctype = 0;    }
      else {                                                         return(NULL); }
   }
   else {                                                            return(NULL); }
   just1 = (Rects->Type & U_PMF_ARRAY_OID ? 0 : 1);
   int Size = Rects->Used + (just1 ? 4 : 0); /* Elements in Rects for array, not for single */
   uint16_t utmp16 =  (ctype ? U_PPF_C : 0)| (PenID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWRECTS,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,                           ph->Used,       1, U_XE},
      {(just1 ? (char *)&Elements : NULL), (just1 ? 4: 0), 1, U_LE}, /* element count if a single Rect was passed in, empty otherwise */ 
      {Rects->Data,                        Rects->Used,    1, U_XE}, /* Elements + Array, already stored in Rects, if an array was passed in, just rect if a single */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWRECTS_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_DRAWSTRING PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  FontID      U_PMF_FONT object in the EMF+ object table (0-63, inclusive)
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    \param  FormatID    U_PMF_STRINGFORMAT object in EMF+ Object Table.
    \param  Length      Number of characters in the string.
    \param  Rect        U_PSEUDO_OBJ containing a U_PMF_RECTF object, string's bounding box
    \param  Text        Array of UFT-16LE unicode characters.
   

    EMF+ manual 2.3.4.14, Microsoft name: EmfPlusDrawString Record, Index 0x1C
*/
U_PSEUDO_OBJ *U_PMR_DRAWSTRING_set(uint32_t FontID, const U_PSEUDO_OBJ *BrushID, 
      uint32_t FormatID, uint32_t Length, const U_PSEUDO_OBJ *Rect, const uint16_t *Text){
   int btype; 
   if(FontID>63){                                 return(NULL); }
   if(!Length){                                   return(NULL); }
   else if (!Text){                               return(NULL); }
   if(!Rect || Rect->Type != U_PMF_RECTF_OID){    return(NULL); }
   if(BrushID){  
      if(      BrushID->Used != 4){               return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){  btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){  btype = 0;    }
      else {                                      return(NULL); }
   }
   else {                                         return(NULL); }
   int Size = BrushID->Used + 2*4 + Rect->Used +2*Length;
   uint16_t utmp16 =  (btype ? U_PPF_B : 0)| (FontID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   uint32_t pad = (0x1 & Length ? 2 : 0);
   Size+=pad;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_DRAWSTRING,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1,             U_XE},
      {BrushID->Data, BrushID->Used, 1,             U_XE},
      {&FormatID,     4,             1,             U_LE},
      {&Length,       4,             1,             U_LE},
      {Rect->Data,    Rect->Used,    1,             U_XE},
      {Text,          2*Length,      1,             U_XE},
      {NULL,          pad,           (pad ? 1 : 0), (pad ? U_XE : U_XX)}, /* Entire record must be a multiple of 4 */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_DRAWSTRING_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_FILLCLOSEDCURVE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  ftype       If U_WINDING use winding fill, else use fill
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    \param  Tension     Controls splines, 0 is straight line, >0 is curved
    \param  Points      U_PSEUDO_OBJ containing a U_PMF_POINT, U_PMF_POINTR or U_PMF_POINTF object
   

    EMF+ manual 2.3.4.15, Microsoft name: EmfPlusFillClosedCurve Record, Index 0x16
*/
U_PSEUDO_OBJ *U_PMR_FILLCLOSEDCURVE_set(int ftype, U_FLOAT Tension, const U_PSEUDO_OBJ *BrushID, const U_PSEUDO_OBJ *Points){
   int btype, ctype, RelAbs;
   int Size=0;
   if(BrushID){ 
      if(      BrushID->Used != 4){              return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){ btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){ btype = 0;    }
      else {                                     return(NULL); }
   }
   else {                                        return(NULL); }
   if(Points){
      if(     Points->Type == U_PMF_POINTR_OID){                     RelAbs = 1; ctype = 0; }
      else if(Points->Type == (U_PMF_POINT_OID  | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 1; }
      else if(Points->Type == (U_PMF_POINTF_OID | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 0; }
      else {                                                         return(NULL);          }
   }
   else {                                                            return(NULL);          }
   Size = BrushID->Used + 4 + Points->Used;
   uint16_t utmp16 =  (btype ? U_PPF_B : 0) | (ctype ? U_PPF_C : 0) |((ftype == U_WINDING) ? U_PPF_F : 0) |(RelAbs ? U_PPF_P : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_FILLCLOSEDCURVE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {BrushID->Data, BrushID->Used, 1, U_XE},
      {&Tension,      4,             1, U_LE},
      {Points->Data,  Points->Used,  1, U_XE}, /* includes Elements */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_FILLCLOSEDCURVE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_FILLELLIPSE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    \param  Rect        U_PSEUDO_OBJ containing a U_PMF_RECT or U_PMF_RECTF object
   

    EMF+ manual 2.3.4.16, Microsoft name: EmfPlusFillEllipse Record, Index 0x0E
*/
U_PSEUDO_OBJ *U_PMR_FILLELLIPSE_set(const U_PSEUDO_OBJ *BrushID, const U_PSEUDO_OBJ *Rect){
   int btype, ctype;
   if(BrushID){ 
      if(      BrushID->Used != 4){              return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){ btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){ btype = 0;    }
      else {                                     return(NULL); }
   }
   else {                                        return(NULL); } 
   if(Rect){
      if(     Rect->Type == U_PMF_RECT_OID ){    ctype = 1;    }
      else if(Rect->Type == U_PMF_RECTF_OID){    ctype = 0;    }
      else {                                     return(NULL); }
   }
   else {                                        return(NULL); }
   int Size = BrushID->Used + Rect->Used;
   uint16_t utmp16 =  (btype ? U_PPF_B : 0) | (ctype ? U_PPF_C : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_FILLELLIPSE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {BrushID->Data, BrushID->Used, 1, U_XE},
      {Rect->Data,    Rect->Used,    1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_FILLELLIPSE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_FILLPATH PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    

    EMF+ manual 2.3.4.17, Microsoft name: EmfPlusFillPath Record, Index 0x14
*/
U_PSEUDO_OBJ *U_PMR_FILLPATH_set(uint32_t PathID, const U_PSEUDO_OBJ *BrushID){
   int btype;
   int Size=0;
   if(PathID>63)return(NULL);
   if(BrushID){ 
      if(      BrushID->Used != 4){              return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){ btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){ btype = 0;    }
      else {                                     return(NULL); }
   }
   else {                                        return(NULL); }
   Size = BrushID->Used;
   uint16_t utmp16 =  (btype ? U_PPF_B : 0) | (PathID & U_FF_MASK_OID8) << U_FF_SHFT_OID8 ;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_FILLPATH,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {BrushID->Data, BrushID->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_FILLPATH_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_FILLPIE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Start       Start angle, >=0.0, degrees clockwise from 3:00
    \param  Sweep       Sweep angle, -360<= angle <=360, degrees clockwise from Start
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    \param  Rect        U_PSEUDO_OBJ containing a U_PMF_RECT or U_PMF_RECTF object
   

    EMF+ manual 2.3.4.18, Microsoft name: EmfPlusFillPie Record, Index 0x10
*/
U_PSEUDO_OBJ *U_PMR_FILLPIE_set(U_FLOAT Start, U_FLOAT Sweep, const U_PSEUDO_OBJ *BrushID, const U_PSEUDO_OBJ *Rect){
   int btype, ctype;
   if(BrushID){ 
      if(      BrushID->Used != 4){              return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){ btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){ btype = 0;    }
      else {                                     return(NULL); }
   }
   else {                                        return(NULL); } 
   if(!Rect){                                    return(NULL); }
   else {
      if(     Rect->Type == U_PMF_RECT_OID ){    ctype = 1;    }
      else if(Rect->Type == U_PMF_RECTF_OID){    ctype = 0;    }
      else {                                     return(NULL); }
   }
   int Size = BrushID->Used + 2*4 + Rect->Used;
   uint16_t utmp16 =  (btype ? U_PPF_B : 0) | (ctype ? U_PPF_C : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_FILLPIE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {BrushID->Data, BrushID->Used, 1, U_XE},
      {&Start,        4,             1, U_LE},
      {&Sweep,        4,             1, U_LE},
      {Rect->Data,    Rect->Used,    1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_FILLPIE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_FILLPOLYGON PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    \param  Points      U_PSEUDO_OBJ containing an array of 3 U_PMF_POINT, U_PMF_POINTR, or U_PMF_POINTF objects
   

    EMF+ manual 2.3.4.19, Microsoft name: EmfPlusFillPolygon Record, Index 0x0C
*/
U_PSEUDO_OBJ *U_PMR_FILLPOLYGON_set(const U_PSEUDO_OBJ *BrushID, const U_PSEUDO_OBJ *Points){
   int btype, ctype, RelAbs;
   if(BrushID){ 
      if(      BrushID->Used != 4){                                  return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){                     btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){                     btype = 0;    }
      else {                                                         return(NULL); }
   }
   else {                                                            return(NULL); }
   if(Points){
      if(     Points->Type ==  U_PMF_POINTR_OID){                    RelAbs = 1; ctype = 0; }
      else if(Points->Type == (U_PMF_POINT_OID  | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 1; }
      else if(Points->Type == (U_PMF_POINTF_OID | U_PMF_ARRAY_OID)){ RelAbs = 0; ctype = 0; }
      else {                                                         return(NULL);          }
   }
   else {                                                            return(NULL);          }
   int Size = BrushID->Used + Points->Used;
   uint16_t utmp16 =  (btype ? U_PPF_B : 0) |  (ctype ? U_PPF_C : 0) |(RelAbs ? U_PPF_P : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_FILLPOLYGON,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {BrushID->Data, BrushID->Used, 1, U_XE},
      {Points->Data,  Points->Used,  1, U_XE}, /* includes Elements */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_FILLPOLYGON_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_FILLRECTS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    \param  Rects       U_PSEUDO_OBJ containing 1 rect OR  a count N followed by N rects.  Rects may be either U_PMF_RECT or U_PMF_RECTF
   

    EMF+ manual 2.3.4.20, Microsoft name: EmfPlusFillRects Record, Index 0x0A
*/
U_PSEUDO_OBJ *U_PMR_FILLRECTS_set(const U_PSEUDO_OBJ *BrushID, const U_PSEUDO_OBJ *Rects){
   int btype, ctype;
   int just1;
   uint32_t Elements=1; /* only used when a single rect is passed in, not an array, not even an array with one member*/
   if(BrushID){ 
      if(      BrushID->Used != 4){                                  return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){                     btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){                     btype = 0;    }
      else {                                                         return(NULL); }
   }
   else {                                                            return(NULL); }
   if(Rects){
      if(      (Rects->Type & U_PMF_MASK_OID) == U_PMF_RECT_OID ){   ctype = 1;    }
      else if( (Rects->Type & U_PMF_MASK_OID) == U_PMF_RECTF_OID){   ctype = 0;    }
      else {                                                         return(NULL); }
   }
   else {                                                            return(NULL); }
   just1 = (Rects->Type & U_PMF_ARRAY_OID ? 0 : 1);
   int Size = BrushID->Used + Rects->Used + (just1 ? 4 : 0); /* Elements in Rects for array, not for single */
   uint16_t utmp16 =  (btype ? U_PPF_B : 0)|(ctype ? U_PPF_C : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_FILLRECTS,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,                           ph->Used,       1, U_XE},
      {BrushID->Data,                      BrushID->Used,  1, U_XE},
      {(just1 ? (char *)&Elements : NULL), (just1 ? 4: 0), 1, U_LE}, /* element count if a single Rect was passed in, empty otherwise */ 
      {Rects->Data,                        Rects->Used,    1, U_XE}, /* Elements + Array, already stored in Rects, if an array was passed in, just rect if a single */
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_FILLRECTS_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_FILLREGION PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  RgnID       U_PMF_REGION object in the EMF+ object table (0-63, inclusive)
    \param  BrushID     U_PSEUDO_OBJ containing a U_PMF_ARGB or a U_PMF_4NUM. Color or U_PMF_BRUSH object in the EMF+ object table (0-63, inclusive)
    

    EMF+ manual 2.3.4.21, Microsoft name: EmfPlusFillRegion Record, Index 0x13
*/
U_PSEUDO_OBJ *U_PMR_FILLREGION_set(uint32_t RgnID, const U_PSEUDO_OBJ *BrushID){
   int btype;
   if(BrushID){ 
      if(      BrushID->Used != 4){                                  return(NULL); }
      else if( BrushID->Type == U_PMF_ARGB_OID){                     btype = 1;    }
      else if( BrushID->Type == U_PMF_4NUM_OID){                     btype = 0;    }
      else {                                                         return(NULL); }
   }
   else {                                                            return(NULL); }
   int Size = BrushID->Used;
   uint16_t utmp16 =  (btype ? U_PPF_B : 0) | (RgnID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_FILLREGION,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {BrushID->Data, BrushID->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_FILLREGION_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_OBJECT PseudoObject from another PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  ObjID       Index for this object in the EMF+ object table (0-63, inclusive)
    \param  Po          U_PSEUDO_OBJ containing an object type that may be stored in the EMF+ object table
*/
U_PSEUDO_OBJ *U_PMR_OBJECT_PO_set(uint32_t ObjID, U_PSEUDO_OBJ *Po){
   if(!Po){ return(NULL); }
   int otype = U_OID_To_OT(Po->Type); /* This will return 0 if the type is not valid for an object */
   if(!otype){ return(NULL); } 
   U_PSEUDO_OBJ *po = U_PMR_OBJECT_set(ObjID, otype, 0, 0, Po->Used, Po->Data); /* 0,0 = rec. not continued, TSize value (ignored)  */
   return(po);
}

/**
    \brief  Create and set a U_PMR_OBJECT PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  ObjID       Index for this object in the EMF+ object table (0-63, inclusive)
    \param  otype       ObjectType enumeration for this Object
    \param  ntype       Set: object definition continues in next record; Clear: this is the sole object definition record
    \param  TSize       If ntype is set the total number of data bytes split across multiple records.  If ntype is clear, it is ignored.
    \param  cbData      Object's data size, in bytes.
    \param  Data        Object's data.  Type from otype.
    

    EMF+ manual 2.3.5.1, Microsoft name: EmfPlusObject Record, Index 0x13

    Normally this is only called by U_PMR_OBJECT_PO_set().
    
    U_PMR_OBJECT records can only hold a maximum of 65020 bytes of data.  If the object is larger than that 
      then multiple U_PMR_OBJECT records are created, one after the other.  If this
      happens each record has cbData following ph, and the ntype flag is set.  If all of the data is less than 65020
      then cbData is NOT entered following ph, and the ntype flag is clear.
    
    Call initially in all cases with ntype clear and TSize = 0.  If the record needs to be fragmented
      the function will call itself recursively to do so.
    
*/
U_PSEUDO_OBJ *U_PMR_OBJECT_set(uint32_t ObjID, int otype, int ntype, uint32_t TSize, size_t cbData, const char *Data){
   uint32_t CSize;
   int      Pad   = UP4(TSize) - TSize;   
   if((otype < U_OT_Brush) || (otype > U_OT_CustomLineCap)){ return(NULL); }
   if(ntype && (cbData > U_OBJRECLIM)){                      return(NULL); }
   if(!Data || !cbData){                                     return(NULL); }
   U_PSEUDO_OBJ *po;
   
   if(!ntype && !TSize && (cbData > U_OBJRECLIM)){  
      ntype = 1;
      TSize = cbData;
      po = U_PO_create(NULL, TSize + 16 * (1 + (TSize/cbData)), 0, U_PMR_OBJECT_OID);
      if(po){
         while(cbData){
            CSize = (cbData > U_OBJRECLIM ? U_OBJRECLIM : cbData);
            U_PSEUDO_OBJ *pot = U_PMR_OBJECT_set(ObjID, otype, ntype, TSize, CSize, Data);
            if(!pot)break;
            U_PSEUDO_OBJ *newpo = U_PO_po_append(po, pot, U_PMF_KEEP_ELEMENTS);
            U_PO_free(&pot);
            if(!newpo)break;
            po = newpo; 
            Data   += U_OBJRECLIM;
            cbData -= CSize;
         }
         if(cbData){ /* some error */
            U_PO_free(&po);
         }
      }
   }
   else {
      /* Send in DataSize, U_PMR_CMN_HDR_set will adjust Header Size with 1-3 pad bytes if needed */
      uint16_t utmp16 =  otype << 8 | (ntype ? U_PPF_N : 0) | (ObjID & U_FF_MASK_OID8) << U_FF_SHFT_OID8;
      U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_OBJECT,utmp16,cbData + (ntype ? 4 : 0));
      const U_SERIAL_DESC List[] = {
         {ph->Data,                 ph->Used,       1,               U_XE               },
         {(ntype ? &TSize : NULL), (ntype ? 4 : 0), (ntype ? 1 : 0), U_LE               },
         {Data,                    cbData,          1,               U_XE               },
         {NULL,                    (Pad ? Pad : 0), (Pad ? 1 : 0),   (Pad ? U_XE : U_XX)}, /* Either 1-3 pad bytes or a terminator */
         {NULL,0,0,U_XX} /* terminator, possibly a second in the list, which is harmless */
      };
      po = U_PMF_SERIAL_set(U_PMR_OBJECT_OID, List);
      U_PO_free(&ph);
   }
   return(po);
}

/**
    \brief  Create and set a U_PMR_SERIALIZABLEOBJECT PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Siepb       U_PSEUDO_OBJ containing a "Serialized image effects parameter block".  One of the ImageEffects objects.

    EMF+ manual 2.3.5.2, Microsoft name: EmfPlusSerializableObject Record, Index 0x38


    This sets an ImageEffect in the renderer, which will be applied to the next EmfPlusDrawImagePoints 
    record that is encountered.  The image effect is "consumed" by that EmfPlusDrawImagePoints record, resetting
    the renderer to its original state.\n  
    
    WARNING!  Windows XP Preview does not show filter effects, whether or not U_PPF_E is set.   They are visible if the EMF+
    file is inserted as an image into PowerPoint.

*/
U_PSEUDO_OBJ *U_PMR_SERIALIZABLEOBJECT_set(const U_PSEUDO_OBJ *Siepb){
   if(!Siepb){                                               return(NULL); }
   uint8_t *GUID = U_OID_To_GUID(Siepb->Type);
   if(!GUID){ return(NULL); }
   /* PO Used is size_t, might be 8 bytes, value in record must be 4 bytes */
   uint32_t Used = Siepb->Used;
   int Size = 16 + 4 + Siepb->Used;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SERIALIZABLEOBJECT,0,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,    ph->Used,	   1, U_XE},
      {GUID,        16, 	   1, U_XE},
      {&Used,       4,  	   1, U_LE},
      {Siepb->Data, Siepb->Used,   1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SERIALIZABLEOBJECT_OID, List);
   U_PO_free(&ph);
   free(GUID);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETANTIALIASMODE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  SMenum      SmoothingMode enumeration
    \param  aatype      Set: anti-aliasing on; Clear: anti-aliasing off
    

    EMF+ manual 2.3.6.1, Microsoft name: EmfPlusSetAntiAliasMode Record, Index 0x1E
*/
U_PSEUDO_OBJ *U_PMR_SETANTIALIASMODE_set(int SMenum, int aatype){
   int Size = 0;
   uint16_t utmp16 =  (aatype ? U_PPF_AA : 0) | (SMenum & U_FF_MASK_AA)<<U_FF_SHFT_AA;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETANTIALIASMODE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETANTIALIASMODE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETCOMPOSITINGMODE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  CMenum      CompositingMode enumeration
    

    EMF+ manual 2.3.6.2, Microsoft name: EmfPlusSetCompositingMode Record, Index 0x23
*/
U_PSEUDO_OBJ *U_PMR_SETCOMPOSITINGMODE_set(int CMenum){
   int Size = 0;
   uint16_t utmp16 =  (CMenum & U_FF_MASK_CM)<<U_FF_SHFT_CM;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETCOMPOSITINGMODE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETCOMPOSITINGMODE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETCOMPOSITINGQUALITY PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  CQenum      CompositingQuality enumeration
    

    EMF+ manual 2.3.6.3, Microsoft name: EmfPlusSetCompositingQuality Record, Index 0x24
*/
U_PSEUDO_OBJ *U_PMR_SETCOMPOSITINGQUALITY_set(int CQenum){
   int Size = 0;
   uint16_t utmp16 =  (CQenum & U_FF_MASK_CQ)<<U_FF_SHFT_CQ;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETCOMPOSITINGQUALITY,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETCOMPOSITINGQUALITY_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETINTERPOLATIONMODE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  IMenum      InterpolationMode enumeration
    

    EMF+ manual 2.3.6.4, Microsoft name: EmfPlusSetInterpolationMode Record, Index 0x21
*/
U_PSEUDO_OBJ *U_PMR_SETINTERPOLATIONMODE_set(int IMenum){
   int Size = 0;
   uint16_t utmp16 =  (IMenum & U_FF_MASK_IM)<<U_FF_SHFT_IM;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETINTERPOLATIONMODE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETINTERPOLATIONMODE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETPIXELOFFSETMODE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  POMenum     PixelOffsetMode enumeration
    

    EMF+ manual 2.3.6.5, Microsoft name: EmfPlusSetPixelOffsetMode Record, Index 0x22
*/
U_PSEUDO_OBJ *U_PMR_SETPIXELOFFSETMODE_set(int POMenum){
   int Size = 0;
   uint16_t utmp16 =  (POMenum & U_FF_MASK_PxOffM) << U_FF_SHFT_PxOffM;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETPIXELOFFSETMODE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETPIXELOFFSETMODE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETRENDERINGORIGIN PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  X            X coordinate of rendering origin.
    \param  Y            Y coordinate of rendering origin.
    

    EMF+ manual 2.3.6.6, Microsoft name: EmfPlusSetRenderingOrigin Record, Index 0x1D
*/
U_PSEUDO_OBJ *U_PMR_SETRENDERINGORIGIN_set(int32_t X, int32_t Y){
   int Size = 2*4;
   uint16_t utmp16 =  0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETRENDERINGORIGIN,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&X,       4,        1, U_LE},
      {&Y,       4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETRENDERINGORIGIN_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETTEXTCONTRAST PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  TGC    Text Gamma correction value (x 1000).
    

    EMF+ manual 2.3.6.7, Microsoft name: EmfPlusSetTextContrast Record, Index 0x20
*/
U_PSEUDO_OBJ *U_PMR_SETTEXTCONTRAST_set(int TGC){
   int Size = 0;
   uint16_t utmp16 =  (TGC & U_FF_MASK_TGC) << U_FF_SHFT_TGC;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETTEXTCONTRAST,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETTEXTCONTRAST_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETTEXTRENDERINGHINT PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  TRHenum     TextRenderingHint enumeration
    

    EMF+ manual 2.3.6.8, Microsoft name: EmfPlusSetTextRenderingHint Record, Index 0x1F
*/
U_PSEUDO_OBJ *U_PMR_SETTEXTRENDERINGHINT_set(int TRHenum){
   int Size = 0;
   uint16_t utmp16 =  (TRHenum & U_FF_MASK_TRH) << U_FF_SHFT_TRH;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETTEXTRENDERINGHINT,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETTEXTRENDERINGHINT_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_BEGINCONTAINER PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  UTenum      UnitType enumeration
    \param  DstRect     a U_PSEUDO_OBJ  containing a U_PMF_RECTF object.  with SrcRect specifies a transformation
    \param  SrcRect     a U_PSEUDO_OBJ  containing a U_PMF_RECTF object.  with DstRect specifies a transformation
    \param  StackID     EMF+ Object Stack Index to use for this graphics container
    

    EMF+ manual 2.3.7.1, Microsoft name: EmfPlusBeginContainer Record, Index 0x27
*/
U_PSEUDO_OBJ *U_PMR_BEGINCONTAINER_set(int UTenum, U_PSEUDO_OBJ *DstRect, U_PSEUDO_OBJ *SrcRect, uint32_t StackID){
   if(UTenum < U_UT_World || UTenum > U_UT_Millimeter){ return(NULL); }
   if(!DstRect || (DstRect->Type != U_PMF_RECTF_OID)){  return(NULL); }
   if(!SrcRect || (SrcRect->Type != U_PMF_RECTF_OID)){  return(NULL); }
   int Size = DstRect->Used + SrcRect->Used + 4;
   uint16_t utmp16 =  (UTenum & U_FF_MASK_UT) << U_FF_SHFT_UT;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_BEGINCONTAINER,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,      ph->Used,      1, U_XE},
      {DstRect->Data, DstRect->Used, 1, U_XE},
      {SrcRect->Data, SrcRect->Used, 1, U_XE},
      {&StackID,      4,             1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_BEGINCONTAINER_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_BEGINCONTAINERNOPARAMS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  StackID     EMF+ Object Stack Index to use for this graphics container
    

    EMF+ manual 2.3.7.2, Microsoft name: EmfPlusBeginContainerNoParams Record, Index 0x28
*/
U_PSEUDO_OBJ *U_PMR_BEGINCONTAINERNOPARAMS_set(int StackID){
   int Size = 4;
   uint16_t utmp16 =  0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_BEGINCONTAINERNOPARAMS,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&StackID, 4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_BEGINCONTAINERNOPARAMS_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_ENDCONTAINER PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  StackID     EMF+ Object Stack Index to use for this graphics container
    

    EMF+ manual 2.3.7.3, Microsoft name: EmfPlusEndContainer Record, Index 0x29
*/
U_PSEUDO_OBJ *U_PMR_ENDCONTAINER_set(int StackID){
   int Size = 4;
   uint16_t utmp16 =  0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_ENDCONTAINER,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&StackID, 4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_ENDCONTAINER_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_RESTORE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  StackID     EMF+ Graphics State Stack to restore from. Must have been put on the GSS with a U_PMR_SAVE.
    

    EMF+ manual 2.3.7.4, Microsoft name: EmfPlusRestore Record, Index 0x26
*/
U_PSEUDO_OBJ *U_PMR_RESTORE_set(int StackID){
   int Size = 4;
   uint16_t utmp16 =  0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_RESTORE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&StackID, 4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_RESTORE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SAVE PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  StackID     EMF+ Graphics State Stack to restore from. Must have been put on the GSS with a U_PMR_SAVE.
    

    EMF+ manual 2.3.7.5, Microsoft name: EmfPlusSave Record, Index 0x25
*/
U_PSEUDO_OBJ *U_PMR_SAVE_set(int StackID){
   int Size = 4;
   uint16_t utmp16 =  0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SAVE,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&StackID, 4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SAVE_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETTSCLIP PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Rects       a U_PSEUDO_OBJ  containing an array of U_PMF_RECT or U_PMF_RECTF objects.
    

    EMF+ manual 2.3.8.1, Microsoft name: EmfPlusSetTSClip Record, Index 0x3A
*/
U_PSEUDO_OBJ *U_PMR_SETTSCLIP_set(U_PSEUDO_OBJ *Rects){
   int ctype;
   uint32_t Elements;
   if(Rects){
      if(     Rects->Type == (U_PMF_RECT_OID  | U_PMF_ARRAY_OID)){ ctype = 1;  Elements = (Rects->Used - 4)/8;  }
      else if(Rects->Type == (U_PMF_RECTF_OID | U_PMF_ARRAY_OID)){ ctype = 0;  Elements = (Rects->Used - 4)/16; }
      else {                                                       return(NULL); }
   }
   else {                                                          return(NULL); }
   int Size = Rects->Used; /* Rects includes Elements */
   uint16_t utmp16 =  (ctype ? U_PPF_K : 0) | (Elements & U_FF_MASK_TSC) << U_FF_SHFT_TSC;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETTSCLIP,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,    ph->Used,    1, U_XE},
      {Rects->Data, Rects->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETTSCLIP_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETTSGRAPHICS PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  vgatype     Set: Palette is VGA basic colors; Clear: Palette is ???
    \param  Tsg         A U_PMF_SETTSGRAPHICS object
    \param  Palette     (optional) a U_PSEUDO_OBJ containing a U_PMF_PALETTE object.
    

    EMF+ manual 2.3.8.2, Microsoft name: EmfPlusSetTSGraphics Record, Index 0x39
*/
U_PSEUDO_OBJ *U_PMR_SETTSGRAPHICS_set(int vgatype, U_PMF_SETTSGRAPHICS *Tsg, U_PSEUDO_OBJ *Palette){
   if(!Tsg){ return(NULL); }
   int Size = sizeof(U_PMF_SETTSGRAPHICS) + (Palette ? Palette->Used : 0);
   uint16_t utmp16 =  (vgatype ? U_PPF_VGA : 0) | (Palette ? U_PPF_PP : 0) ;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETTSGRAPHICS,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data,                         ph->Used,                     1, U_XE},
      {&(Tsg->AntiAliasMode),            1,                            1, U_XE},
      {&(Tsg->TextRenderHint),           1,                            1, U_XE},
      {&(Tsg->CompositingMode),          1,                            1, U_XE},
      {&(Tsg->CompositingQuality),       1,                            1, U_XE},
      {&(Tsg->RenderOriginX),            2,                            1, U_LE},
      {&(Tsg->RenderOriginY),            2,                            1, U_LE},
      {&(Tsg->TextContrast),             2,                            1, U_LE},
      {&(Tsg->FilterType),               1,                            1, U_XE},
      {&(Tsg->PixelOffset),              1,                            1, U_XE},
      {&(Tsg->WorldToDevice),            4,                            6, U_LE},
      {(Palette ? Palette->Data : NULL), (Palette ? Palette->Used: 0), 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETTSGRAPHICS_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_MULTIPLYWORLDTRANSFORM PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  xmtype      Set: Post multiply; Clear: Pre multiply
    \param  Tm          a U_PSEUDO_OBJ containing a U_PMF_TRANSFORMMATRIX. (Transformation matrix)
    

    EMF+ manual 2.3.9.1, Microsoft name: EmfPlusMultiplyWorldTransform Record, Index 0x2C
*/
U_PSEUDO_OBJ *U_PMR_MULTIPLYWORLDTRANSFORM_set(int xmtype, U_PSEUDO_OBJ *Tm){
   if(!Tm || (Tm->Type != U_PMF_TRANSFORMMATRIX_OID)){ return(NULL); }
   int Size = Tm->Used;
   uint16_t utmp16 =  (xmtype ? U_PPF_XM : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_MULTIPLYWORLDTRANSFORM,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {Tm->Data, Tm->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_MULTIPLYWORLDTRANSFORM_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_RESETWORLDTRANSFORM PseudoObject
    \return Pointer to PseudoObject, NULL on error
    

    EMF+ manual 2.3.9.2, Microsoft name: EmfPlusResetWorldTransform Record, Index 0x2B
*/
U_PSEUDO_OBJ *U_PMR_RESETWORLDTRANSFORM_set(void){
   int Size = 0;
   uint16_t utmp16 =  0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_RESETWORLDTRANSFORM,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_RESETWORLDTRANSFORM_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_ROTATEWORLDTRANSFORM PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  xmtype      Set: Post multiply; Clear: Pre multiply
    \param  Angle       Rotation angle, in degrees
    

    EMF+ manual 2.3.9.3, Microsoft name: EmfPlusRotateWorldTransform Record, Index 0x2F
*/
U_PSEUDO_OBJ *U_PMR_ROTATEWORLDTRANSFORM_set(int xmtype, U_FLOAT Angle){
   int Size = 4;
   uint16_t utmp16 =  (xmtype ? U_PPF_XM : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_ROTATEWORLDTRANSFORM,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&Angle,   4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_ROTATEWORLDTRANSFORM_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SCALEWORLDTRANSFORM PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  xmtype      Set: Post multiply; Clear: Pre multiply
    \param  X           Scale in X
    \param  Y           Scale in Y

    EMF+ manual 2.3.9.4, Microsoft name: EmfPlusScaleWorldTransform Record, Index 0x2E
*/
U_PSEUDO_OBJ *U_PMR_SCALEWORLDTRANSFORM_set(int xmtype, U_FLOAT X, U_FLOAT Y){
   int Size = 2*4;
   uint16_t utmp16 =  (xmtype ? U_PPF_XM : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SCALEWORLDTRANSFORM,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&X,       4,        1, U_LE},
      {&Y,       4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SCALEWORLDTRANSFORM_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETPAGETRANSFORM PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  PUenum   Page Unit, in UnitType enumeration
    \param  Scale    Scale factor to convert page space to device space
    
    

    EMF+ manual 2.3.9.5, Microsoft name: EmfPlusSetPageTransform Record, Index 0x30

    Defines Page Space -> Device Space transformation
*/
U_PSEUDO_OBJ *U_PMR_SETPAGETRANSFORM_set(int PUenum, U_FLOAT Scale){
   int Size = 4;
   uint16_t utmp16 =  (PUenum & U_FF_MASK_PU) << U_FF_SHFT_PU;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETPAGETRANSFORM,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&Scale,    4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETPAGETRANSFORM_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_SETWORLDTRANSFORM PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  Tm          a U_PSEUDO_OBJ containing a U_PMF_TRANSFORMMATRIX. (Transformation matrix)
    
    

    EMF+ manual 2.3.9.6, Microsoft name: EmfPlusSetWorldTransform Record, Index 0x2A

    Defines  World Space -> Page Space transformation
*/
U_PSEUDO_OBJ *U_PMR_SETWORLDTRANSFORM_set(U_PSEUDO_OBJ *Tm){
   if(!Tm || (Tm->Type != U_PMF_TRANSFORMMATRIX_OID)){ return(NULL); }
   int Size = Tm->Used;
   uint16_t utmp16 = 0;
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_SETWORLDTRANSFORM,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {Tm->Data, Tm->Used, 1, U_XE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_SETWORLDTRANSFORM_OID, List);
   U_PO_free(&ph);
   return(po);
}

/**
    \brief  Create and set a U_PMR_TRANSLATEWORLDTRANSFORM PseudoObject
    \return Pointer to PseudoObject, NULL on error
    \param  xmtype      Set: Post multiply; Clear: Pre multiply
    \param  Dx          X offset
    \param  Dy          Y offset
    

    EMF+ manual 2.3.9.7, Microsoft name: EmfPlusTranslateWorldTransform Record, Index 0x2D
*/
U_PSEUDO_OBJ *U_PMR_TRANSLATEWORLDTRANSFORM_set(int xmtype, U_FLOAT Dx, U_FLOAT Dy){
   int Size = 2*4;
   uint16_t utmp16 =  (xmtype ? U_PPF_XM : 0);
   U_PSEUDO_OBJ *ph = U_PMR_CMN_HDR_set(U_PMR_TRANSLATEWORLDTRANSFORM,utmp16,Size);
   const U_SERIAL_DESC List[] = {
      {ph->Data, ph->Used, 1, U_XE},
      {&Dx,      4,        1, U_LE},
      {&Dy,      4,        1, U_LE},
      {NULL,0,0,U_XX}
   };
   U_PSEUDO_OBJ *po = U_PMF_SERIAL_set(U_PMR_TRANSLATEWORLDTRANSFORM_OID, List);
   U_PO_free(&ph);
   return(po);
}

/*

   end of U_PMF_*_set() functions 
   =====================================================================================
   start of U_PMF_*_get() functions 

      These functions all take a blimit value so that they can check if the data description in the fields
      they process extend beyond the end of the record.

*/


//! \cond
/* core _get functions, not accessed outside of this routine */

/* get copies of up to 0-6 consecutive 4 byte values and a pointer to the rest */
int U_PMF_CORE1_get(const char *contents, void *v1, void *v2, void *v3, void *v4, void *v5, void *v6, const char **vR){
    if(v1){                U_PMF_MEMCPY_SRCSHIFT(v1, &contents, 4);
       if(v2){             U_PMF_MEMCPY_SRCSHIFT(v2, &contents, 4);
          if(v3){          U_PMF_MEMCPY_SRCSHIFT(v3, &contents, 4);
             if(v4){       U_PMF_MEMCPY_SRCSHIFT(v4, &contents, 4);
                if(v5){    U_PMF_MEMCPY_SRCSHIFT(v5, &contents, 4);
                   if(v6){ U_PMF_MEMCPY_SRCSHIFT(v6, &contents, 4); }}}}}}
    if(vR){ *vR = contents; }
    return(1);
}
//! \endcond


/**
    \brief Get data from a U_PMF_BRUSH object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Version    EmfPlusGraphicsVersion object
    \param  Type       BrushType Enumeration
    \param  Data       one of the 5 types of Brush data
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.1.1, Microsoft name: EmfPlusBrush Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_BRUSH_get(const char *contents, uint32_t *Version, uint32_t *Type, const char **Data, const char *blimit){
    if(!contents || !Version || !Type || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents,sizeof(U_PMF_BRUSH), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Version, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Type,    4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_CUSTOMLINECAP object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Version    EmfPlusGraphicsVersion object
    \param  Type       CustomLineCapData Enumeration
    \param  Data       one of the 2 types of Linecap data
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.1.2, Microsoft name: EmfPlusCustomLineCap Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_CUSTOMLINECAP_get(const char *contents, uint32_t *Version, uint32_t *Type, const char **Data, const char *blimit){
    if(!contents || !Version || !Type || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_CUSTOMLINECAP), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Version, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Type,    4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_FONT object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Version    EmfPlusGraphicsVersion object
    \param  EmSize     em size in units of SizeUnit
    \param  SizeUnit   UnitType enumeration
    \param  FSFlags    FontStyle flags
    \param  Length     Number of Unicode Characters in FamilyName
    \param  Data       Unicode (UTF-16LE) name of font family

    EMF+ manual 2.2.1.3, Microsoft name: EmfPlusFont Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_FONT_get(const char *contents, uint32_t *Version, U_FLOAT *EmSize, uint32_t *SizeUnit,
      int32_t *FSFlags, uint32_t *Length, const char **Data, const char *blimit){
    if(!contents || !Version || !EmSize || !SizeUnit || !FSFlags || !Length || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_FONT), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Version,  4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, EmSize,   4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, SizeUnit, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, FSFlags,  4, 1, U_LE);
    contents += 4; /* Reserved field, which is ignored */
    U_PMF_SERIAL_get(&contents, Length,   4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}


/**
    \brief Get data from a U_PMF_IMAGE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Version    EmfPlusGraphicsVersion object
    \param  Type       ImageDataType Enumeration
    \param  Data       one of the 2 types of image data

    EMF+ manual 2.2.1.4, Microsoft name: EmfPlusImage Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_IMAGE_get(const char *contents, uint32_t *Version, uint32_t *Type, const char **Data, const char *blimit){
    if(!contents || !Version || !Type || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IMAGE), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Version, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Type,    4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_IMAGEATTRIBUTES object
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Version     EmfPlusGraphicsVersion object
    \param  WrapMode    WrapMode object
    \param  ClampColor  EmfPlusARGB object
    \param  ObjectClamp ObjectClamp Identifiers

    EMF+ manual 2.2.1.5, Microsoft name: EmfPlusImageAttributes Object
*/
int U_PMF_IMAGEATTRIBUTES_get(const char *contents, uint32_t *Version, uint32_t *WrapMode, uint32_t *ClampColor,
      uint32_t *ObjectClamp, const char *blimit){
    if(!contents || !Version || !WrapMode || !ClampColor || !ObjectClamp || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IMAGEATTRIBUTES), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Version,    4, 1, U_LE);
    contents += 4; /* Skip Reserved 1*/
    U_PMF_SERIAL_get(&contents, WrapMode,   4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, ClampColor, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, ObjectClamp,4, 1, U_LE);
    /* Skip Reserved 2*/
    return(1);
}

/**
    \brief Get data from a U_PMF_PATH object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Version    EmfPlusGraphicsVersion object
    \param  Count      Number of points and point types in this object
    \param  Flags      PathPoint Flags
    \param  Points     array of points type PMFPointR, PMFPoint, or PMFPointF
    \param  Types      array of U_PMF_PATHPOINTTYPERLE and/or U_PMF_PATHPOINTTYPE

    EMF+ manual 2.2.1.6, Microsoft name: EmfPlusPath Object

    Caller must check Types for possible memory access violations if type can be U_PMF_PATHPOINTTYPERLE.
*/
int U_PMF_PATH_get(const char *contents, uint32_t *Version, uint32_t *Count, uint16_t *Flags, 
      const char **Points, const char **Types, const char *blimit){
    if(!contents || !Version || !Count || !Flags || !Points || !Types || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_PATH), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Version,    4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Count,      4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Flags,      2, 1, U_LE);
    contents+=2; /* reserved */
    uint32_t sizeP, sizeT;
    if(*Flags      & U_PPF_P){ 
       sizeP  = U_PMF_LEN_REL715(contents,*Count); //DEBUG
       printf("DEBUG U_PMF_PATH_get count:%d LENREL715:%d\n",*Count,sizeP);fflush(stdout);
    }
    else if(*Flags & U_PPF_C){ sizeP = *Count * sizeof(U_PMF_POINT);   }
    else {                     sizeP = *Count * sizeof(U_PMF_POINTF);  }
    if(IS_MEM_UNSAFE(contents, sizeP, blimit))return(0);
    U_PMF_PTRSAV_SHIFT(Points, &contents, 0);
    contents += sizeP;
    /* this limit is correct if there are only U_PMF_PATHPOINTTYPE PointTypes, it is a lower bound if
       there can also be U_PMF_PATHPOINTTYPERLE */
    sizeT = *Count * sizeof(U_PMF_PATHPOINTTYPE);
    if(IS_MEM_UNSAFE(contents, sizeT, blimit))return(0);
    U_PMF_PTRSAV_SHIFT(Types, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_PEN object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Version    EmfPlusGraphicsVersion object
    \param  Type       must be zero
    \param  PenData    Pen description
    \param  Brush      Brush Description 

    EMF+ manual 2.2.1.7, Microsoft name: EmfPlusPen Object

    Caller must check Brush and PenData for possible memory access violations.
*/
int U_PMF_PEN_get(const char *contents, uint32_t *Version, uint32_t *Type, const char **PenData, const char **Brush, const char *blimit){
    if(!contents || !Type || !PenData || !Brush || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_PEN), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Version, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Type,    4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(PenData, &contents, 0);
    *Brush = *PenData + U_PMF_LEN_PENDATA(*PenData);
    return(1);
}
    
/**
    \brief Get data from a U_PMF_REGION object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Version    EmfPlusGraphicsVersion object
    \param  Count      Number of CHILD nodes.  This is one less than the total number of U_PMF_REGIONNODE objects in Nodes.
    \param  Nodes      Nodes defining region

    EMF+ manual 2.2.1.8, Microsoft name: EmfPlusRegion Object
*/
int U_PMF_REGION_get(const char *contents, uint32_t *Version, uint32_t *Count, const char **Nodes, const char *blimit){
    if(!contents || !Version || !Count || !Nodes || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_REGION), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Version, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Count,   4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Nodes, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_STRINGFORMAT object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Sfs        pointer to U_PMF_STRINGFORMAT structure, with no variable part
    \param  Data       pointer to variable part

    EMF+ manual 2.2.1.9, Microsoft name: EmfPlusStringFormat Object
*/
int U_PMF_STRINGFORMAT_get(const char *contents, U_PMF_STRINGFORMAT *Sfs, const char **Data, const char *blimit){
    if(!contents || !Sfs || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_STRINGFORMAT), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Sfs, 4, 15, U_LE);
    *Data = contents;
    return(1);
}

/**
    \brief Get data from a U_PMF_ARGB object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Blue       Blue  color (0-255)
    \param  Green      Green color (0-255)
    \param  Red        Red   color (0-255)
    \param  Alpha      Alpha       (0-255)

    EMF+ manual 2.2.2.1, Microsoft name: EmfPlusARGB Object
*/
int U_PMF_ARGB_get(const char *contents, uint8_t *Blue, uint8_t *Green, uint8_t *Red, uint8_t *Alpha, const char *blimit){
    if(!contents || !Blue || !Green || !Red || !Alpha || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_ARGB), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Blue,  1, 1, U_XE);
    U_PMF_SERIAL_get(&contents, Green, 1, 1, U_XE);
    U_PMF_SERIAL_get(&contents, Red,   1, 1, U_XE);
    U_PMF_SERIAL_get(&contents, Alpha, 1, 1, U_XE);
    return(1);
}

/**
    \brief Get data from a U_PMF_BITMAP object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Bs         pointer to U_PMF_BITMAP structure, with no variable part
    \param  Data       pointer to variable part

    EMF+ manual 2.2.2.2, Microsoft name: EmfPlusBitmap Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_BITMAP_get(const char *contents, U_PMF_BITMAP *Bs, const char **Data, const char *blimit){
    if(!contents || !Bs || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_BITMAP), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Bs, 4, 5, U_LE); // width, height, stride, pixelformat, type
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0); // bitmapdata
    return(1);
}

/**
    \brief Get data from a U_PMF_BITMAPDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Ps         pointer to U_PMF_PALETTE structure, with no variable part
    \param  Colors     Color part of U_PMF_PALETTE object
    \param  Data       An array of bytes, meaning depends on fields in U_PMF_BITMAP object and the PixelFormat enumeration.

    EMF+ manual 2.2.2.3, Microsoft name: EmfPlusBitmapData Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_BITMAPDATA_get(const char *contents, U_PMF_PALETTE *Ps, const char **Colors, const char **Data, const char *blimit){
    if(!contents || !Ps || !Colors || !Data  || !blimit){ return(0); }
    /* this structure is entirely optional */
    if(IS_MEM_UNSAFE(contents, 4*2, blimit))return(0);
    U_PMF_SERIAL_get(&contents, Ps, 4, 2, U_LE);
    U_PMF_PTRSAV_SHIFT(Colors, &contents, Ps->Elements * sizeof(U_PMF_ARGB));
    /* difficult to know how big the actual bitmap will be, just return the pointer to it untested */
    U_PMF_PTRSAV_SHIFT(Data,  &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_BLENDCOLORS object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Elements   Number of members in Positions and Colors
    \param  Positions  Caller must free.  Pointer to memory holding positions along gradient line.  
    \param  Colors     Caller must NOT free memory, Pointer to memory holding colors at positions on gradient line.  

    EMF+ manual 2.2.2.4, Microsoft name: EmfPlusBlendColors Object
*/
int U_PMF_BLENDCOLORS_get(const char *contents, uint32_t *Elements, U_FLOAT **Positions, const char **Colors, const char *blimit){
    if(!contents || !Positions || !Colors || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_BLENDCOLORS), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
    if(IS_MEM_UNSAFE(contents, *Elements * 4, blimit))return(0);
    if(!U_PMF_SERIAL_array_copy_get(&contents, (void **)Positions, 4, *Elements, U_LE,1)){ return(0); }
    U_PMF_PTRSAV_SHIFT(Colors,  &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_BLENDFACTORS object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Elements   members in each array
    \param  Positions  Caller must free.  Pointer to memory holding positions along gradient line.  
    \param  Factors    Caller must free.  Pointer to memory holding blending factors, 0.0->1.0 values, inclusive along gradient line.  

    EMF+ manual 2.2.2.5, Microsoft name: EmfPlusBlendFactors Object
*/
int U_PMF_BLENDFACTORS_get(const char *contents, uint32_t *Elements, U_FLOAT **Positions, U_FLOAT **Factors, const char *blimit){
    if(!contents || !Elements || !Positions || !Factors || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_BLENDFACTORS), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
    if(IS_MEM_UNSAFE(contents, *Elements * 4 * 2, blimit))return(0);
    if(!U_PMF_SERIAL_array_copy_get(&contents, (void **)Positions,  4, *Elements, U_LE, 1)){ return(0); }
    if(!U_PMF_SERIAL_array_copy_get(&contents, (void **)Factors,    4, *Elements, U_LE, 1)){
       free(*Positions);
       return(0);
    }
    return(1);
}

/**
    \brief Get data from a U_PMF_BOUNDARYPATHDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Size       bytes in Data
    \param  Data       boundary of the brush

    EMF+ manual 2.2.2.6, Microsoft name: EmfPlusBoundaryPathData Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_BOUNDARYPATHDATA_get(const char *contents, int32_t *Size, const char **Data, const char *blimit){
    if(!contents || !Size || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_BOUNDARYPATHDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Size, 4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data,  &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_BOUNDARYPOINTDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Elements   Members in Points
    \param  Points     Caller must free.  Pointer to memory holding points along gradient line. Boundary of the brush.

    EMF+ manual 2.2.2.7, Microsoft name: EmfPlusBoundaryPointData Object
*/
int U_PMF_BOUNDARYPOINTDATA_get(const char *contents, int32_t *Elements, U_PMF_POINTF **Points, const char *blimit){
    if(!contents || !Elements || !Points || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_BOUNDARYPOINTDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
    if(IS_MEM_UNSAFE(contents, *Elements * 2, blimit))return(0);
    if(!U_PMF_SERIAL_array_copy_get(&contents, (void **)Points, 4, *Elements * 2, U_LE, 1)){ return(0); }
    return(1);
}

/**
    \brief Get data from a U_PMF_CHARACTERRANGE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  First      First position in range
    \param  Length     Range length

    EMF+ manual 2.2.2.8, Microsoft name: EmfPlusCharacterRange Object
*/
int U_PMF_CHARACTERRANGE_get(const char *contents, int32_t *First, int32_t *Length, const char *blimit){
    if(!contents || !First || !Length || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_CHARACTERRANGE), blimit))return(0);
    U_PMF_SERIAL_get(&contents, First,  4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Length, 4, 1, U_LE);
    return(1);
}

/**
    \brief Get data from a U_PMF_COMPOUNDLINEDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Elements   Members in the array
    \param  Widths     Caller must free.  Pointer to memory holding Line or gap widths (0.0 <-> 1.0, fraction of total line width ).  

    EMF+ manual 2.2.2.9, Microsoft name: EmfPlusCompoundLineData Object
*/
int U_PMF_COMPOUNDLINEDATA_get(const char *contents, int32_t *Elements, U_FLOAT **Widths, const char *blimit){
    if(!contents || !Elements || !Widths || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_COMPOUNDLINEDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
    if(IS_MEM_UNSAFE(contents, *Elements * sizeof(U_FLOAT), blimit))return(0);
    *Widths = (U_FLOAT *)malloc(*Elements * sizeof(U_FLOAT));
    if(!*Widths){ return(0); }
    U_PMF_SERIAL_get(&contents, *Widths, 4, *Elements, U_LE);
    return(1);
}

/**
    \brief Get data from a U_PMF_COMPRESSEDIMAGE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Data       Stored image in one of the supported formats.

    EMF+ manual 2.2.2.10, Microsoft name: EmfPlusCompressedImage Object
    

    This function does not do anything useful, but it is included so that all objects have a corresponding _get().

    Caller must check Data for possible memory access violations.
*/
int U_PMF_COMPRESSEDIMAGE_get(const char *contents, const char **Data, const char *blimit){
    if(!contents || !Data || !blimit){ return(0); }
    if(contents >= blimit)return(0);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_CUSTOMENDCAPDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Size       Bytes in Data
    \param  Data       Description of linecap

    EMF+ manual 2.2.2.11, Microsoft name: EmfPlusCustomEndCapData Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_CUSTOMENDCAPDATA_get(const char *contents, int32_t *Size, const char **Data, const char *blimit){
    if(!contents || !Size || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_CUSTOMENDCAPDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Size, 4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_CUSTOMLINECAPARROWDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Ccad       pointer to U_PMF_CUSTOMLINECAPARROWDATA structure

    EMF+ manual 2.2.2.12, Microsoft name: EmfPlusCustomLineCapArrowData Object
*/
int U_PMF_CUSTOMLINECAPARROWDATA_get(const char *contents, U_PMF_CUSTOMLINECAPARROWDATA *Ccad, const char *blimit){
    if(!contents || !Ccad || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_CUSTOMLINECAPARROWDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Ccad, 4, 13, U_LE);
    return(1);
}

/**
    \brief Get data from a U_PMF_CUSTOMLINECAPDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Clcd       pointer to U_PMF_CUSTOMLINECAPDATA structure, with no variable part
    \param  Data       variable part of U_PMF_CUSTOMLINECAPDATA

    EMF+ manual 2.2.2.13, Microsoft name: EmfPlusCustomLineCapData Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_CUSTOMLINECAPDATA_get(const char *contents, U_PMF_CUSTOMLINECAPDATA *Clcd, const char **Data, const char *blimit){
    if(!contents || !Clcd || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_CUSTOMLINECAPDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Clcd, 4, 12, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_CUSTOMLINECAPOPTIONALDATA object
    \return on success 3,5, or 7 (for varying combinations of data present) or 1 (no data is present), 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      bits set to indicate the presence of FillData and/or LineData
    \param  FillData   Path to fill (optional)
    \param  LineData   Path to stroke (optional)

    EMF+ manual 2.2.2.14, Microsoft name: EmfPlusCustomLineCapOptionalData Object

    Caller must check LineData for possible memory access violations.
*/
int U_PMF_CUSTOMLINECAPOPTIONALDATA_get(const char *contents, uint32_t Flags, const char **FillData, const char **LineData, const char *blimit){
    uint32_t length;
    int status = 1;
    if(!contents || !*FillData || !*LineData || !blimit){ return(0); }
    /* this structure is entirely optional */
    if(Flags & U_CLCD_FillPath){
       if(!FillData){ return(0); }
       if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
       U_PMF_SERIAL_get(&contents, &length, 4, 1, U_LE);
       if(IS_MEM_UNSAFE(contents, length, blimit))return(0);
       contents -= 4;  /* undo the unneeded shift from preceding */
       U_PMF_PTRSAV_SHIFT(FillData, &contents, 4 + length);
       status += 2; 
    }
    else { *FillData = NULL; }

    if(Flags & U_CLCD_LinePath){
       if(!LineData){ return(0); }
       if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
       U_PMF_SERIAL_get(&contents, &length, 4, 1, U_LE);
       if(IS_MEM_UNSAFE(contents, length, blimit))return(0);
       contents -= 4;  /* undo the unneeded shift from preceding */
       U_PMF_PTRSAV_SHIFT(LineData, &contents, 0);
       status += 4;
    }
    else { *LineData = NULL; }
    return(status);
}

/**
    \brief Get data from a U_PMF_CUSTOMSTARTCAPDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Size       Bytes in Data
    \param  Data       Description of linecap

    EMF+ manual 2.2.2.15, Microsoft name: EmfPlusCustomStartCapData Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_CUSTOMSTARTCAPDATA_get(const char *contents, int32_t *Size, const char **Data, const char *blimit){
    if(!contents || !Size || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_CUSTOMSTARTCAPDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Size, 4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_DASHEDLINEDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Elements   Members in the array
    \param  Lengths    Caller must free.  Pointer to memory holding lengths of dashes and spaces.

    EMF+ manual 2.2.2.16, Microsoft name: EmfPlusDashedLineData Object
*/
int U_PMF_DASHEDLINEDATA_get(const char *contents, int32_t *Elements, U_FLOAT **Lengths, const char *blimit){
    if(!contents || !Elements || !Lengths || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_DASHEDLINEDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
    if(IS_MEM_UNSAFE(contents, *Elements * sizeof(U_FLOAT), blimit))return(0);
    *Lengths = (U_FLOAT *)malloc(*Elements * sizeof(U_FLOAT));
    if(!*Lengths){ return(0); }
    U_PMF_SERIAL_get(&contents, *Lengths, 4, *Elements, U_LE);
    return(1);
}

/**
    \brief Get data from a U_PMF_FILLPATHOBJ object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Size       Bytes in Data
    \param  Data       Path specification

    EMF+ manual 2.2.2.17, Microsoft name: EmfPlusFillPath Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_FILLPATHOBJ_get(const char *contents, int32_t *Size, const char **Data, const char *blimit){
    if(!contents || !Size || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_FILLPATHO), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Size, 4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_FOCUSSCALEDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Count      must be 2
    \param  ScaleX     value 0.0 <-> 1.0
    \param  ScaleY     value 0.0 <-> 1.0

    EMF+ manual 2.2.2.18, Microsoft name: EmfPlusFocusScaleData Object
*/
int U_PMF_FOCUSSCALEDATA_get(const char *contents, uint32_t *Count, U_FLOAT *ScaleX, U_FLOAT *ScaleY, const char *blimit){
    if(!contents || !Count || !ScaleX || !ScaleY || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_FOCUSSCALEDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Count,  4, 1, U_LE);
    if(*Count != 2){ return(0); }
    U_PMF_SERIAL_get(&contents, ScaleX, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, ScaleY, 4, 1, U_LE);
    return(1);
}

/**
    \brief Get data from a U_PMF_GRAPHICSVERSION object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Signature  Must be U_GFVR_PMF (0xDBC01)
    \param  GrfVersion GraphicsVersion enumeration

    EMF+ manual 2.2.2.19, Microsoft name: EmfPlusGraphicsVersion Object
*/
int U_PMF_GRAPHICSVERSION_get(const char *contents, int *Signature, int *GrfVersion, const char *blimit){
    uint32_t tmp;
    if(!contents || !Signature || !GrfVersion || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_GRAPHICSVERSION), blimit))return(0);
    memcpy(&tmp, contents, 4);
    *Signature  = tmp >> 12;
    *GrfVersion = tmp & U_GFVR_MASKLO;
    return(1);
}

/**
    \brief Get data from a U_PMF_HATCHBRUSHDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Style      HatchStyle enumeration
    \param  Foreground Hatch pattern line color
    \param  Background Hatch pattern bkground color

    EMF+ manual 2.2.2.20, Microsoft name: EmfPlusHatchBrushData Object
*/
int U_PMF_HATCHBRUSHDATA_get(const char *contents, uint32_t *Style, U_PMF_ARGB *Foreground, U_PMF_ARGB *Background, const char *blimit){
    if(!contents || !Style || !Foreground || !Background || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_HATCHBRUSHDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Style,      4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Foreground, 4, 1, U_XE);
    U_PMF_SERIAL_get(&contents, Background, 4, 1, U_XE);
    return(1);
}

/**
    \brief Get data from a U_PMF_INTEGER7 object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Value      7 bit signed integer (stored in an integer)
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.21, Microsoft name: EmfPlusInteger7 Object
*/
int U_PMF_INTEGER7_get(const char **contents, U_FLOAT *Value, const char *blimit){
    uint8_t tmp;
    if(!contents || !*contents || !Value || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(*contents, 1, blimit))return(0); /* past end of buffer */
    if(**contents & U_TEST_INT7)return(0);  /* this bit must be 0 in this object type */
    U_PMF_SERIAL_get(contents, &tmp, 1, 1, U_XE);
    if(tmp & U_SIGN_INT7){
       tmp |= U_TEST_INT7;  /* now it has the bit pattern of a signed int8_t */
       *Value = *(int8_t *)&tmp;
    }
    else {
       *Value = tmp;
    }
    return(1);
}

/**
    \brief Get data from a U_PMF_INTEGER15 object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Value      15 bit signed integer (stored in an integer)
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.22, Microsoft name: EmfPlusInteger15 Object
*/
int U_PMF_INTEGER15_get(const char **contents, U_FLOAT *Value, const char *blimit){
    if(!contents || !*contents || !Value || !blimit){ return(0); }
    uint16_t tmp;
    if(IS_MEM_UNSAFE(*contents, 2, blimit))return(0); /* past end of buffer */
    if(!(**contents & U_TEST_INT7))return(0);  /* this bit must be 1 in this object type */
    U_PMF_SERIAL_get(contents, &tmp, 2, 1, U_BE);
    tmp &= U_MASK_INT15;   /* drop the 7/15 flag from the most significant bit */
    if(tmp & U_SIGN_INT15){
       tmp |= U_TEST_INT15;  /* now it has the bit pattern of a signed int16_t */
       *Value = *(int16_t *)&tmp;
    }
    else {
       *Value = tmp;
    }
    return(1);
}

/**
    \brief Get data from a U_PMF_LANGUAGEIDENTIFIER object
    \return 1 on success, 0 on error
    \param  LId        U_PMF_LANGUAGEIDENTIFIER from which to extract data
    \param  SubLId     Example: code for USA
    \param  PriLId     Example: code for English
    


    EMF+ manual 2.2.2.23, Microsoft name: EmfPlusLanguageIdentifier Object

    This type is defined as 16 bits in the manual section, but it is only ever used as part of a 32 bit field!
*/
int U_PMF_LANGUAGEIDENTIFIER_get(U_PMF_LANGUAGEIDENTIFIER LId, int *SubLId, int *PriLId){
    if(!SubLId || !PriLId){ return(0); }
    *SubLId = (LId >> U_FF_SHFT_SUBLID ) & U_FF_MASK_SUBLID;         
    *PriLId = (LId >> U_FF_SHFT_PRILID ) & U_FF_MASK_PRILID;
    /* 16 bits above that are not used */
    return(1);
}

/**
    \brief Get data from a U_PMF_LINEARGRADIENTBRUSHDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Lgbd       U_PMF_LINEARGRADIENTBRUSHDATA structure, with no variable part
    \param  Data       variable part of U_PMF_LINEARGRADIENTBRUSHDATA
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.24, Microsoft name: EmfPlusLinearGradientBrushData Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_LINEARGRADIENTBRUSHDATA_get(const char *contents, U_PMF_LINEARGRADIENTBRUSHDATA *Lgbd, const char **Data, const char *blimit){
    if(!contents || !Lgbd || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_LINEARGRADIENTBRUSHDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Lgbd,		      4, 6, U_LE); /* Flags, WrapMode, RectF*/
    U_PMF_SERIAL_get(&contents, &(Lgbd->StartColor),  4, 4, U_XE); /* StartColor, EndColor, Reserved1 & 2 */
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_LINEARGRADIENTBRUSHOPTIONALDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      BrushData flags - indicates which of the following date fields are present.
    \param  Tm         Transformation matrix
    \param  Bc         U_PMF_BLENDCOLORS object or NULL
    \param  BfH        U_PMF_BLENDFACTORS (H) object or NULL
    \param  BfV        U_PMF_BLENDFACTORS (V) object or NULL (WARNING, GDI+ defines this field but does not render it.  DO NOT USE.)
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.25, Microsoft name: EmfPlusLinearGradientBrushOptionalData Object

*/
int U_PMF_LINEARGRADIENTBRUSHOPTIONALDATA_get(const char *contents, uint32_t Flags, U_PMF_TRANSFORMMATRIX *Tm, 
      const char **Bc, const char **BfH, const char **BfV, const char *blimit){
    uint32_t Elements;
    if(!contents || !Tm|| !Bc || !BfH || !BfV || !blimit){ return(0); }
    /* all of the fields are optional! */
    *Bc = *BfH = *BfV = NULL;
    if(Flags & U_BD_Transform){
       if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_ROTMATRIX), blimit))return(0);
       U_PMF_SERIAL_get(&contents, Tm, 4, 6, U_LE);
    }
    if(Flags & U_BD_PresetColors){
       if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
       U_PMF_SERIAL_get(&contents, &Elements, 4, 1, U_LE);  /* starts with a 4 byte count*/
       if(IS_MEM_UNSAFE(contents, Elements * ( sizeof(U_FLOAT) + sizeof(U_PMF_ARGB)), blimit))return(0);
       contents-=4; /* back up to the front of the count, as it is part of the data field */
       U_PMF_PTRSAV_SHIFT(Bc, &contents, 0);
    }
    else if(Flags & U_BD_BlendFactorsH){
       U_PMF_SERIAL_get(&contents, &Elements, 4, 1, U_LE);  /* starts with a 4 byte count*/
       if(IS_MEM_UNSAFE(contents, Elements * 2 * sizeof(U_FLOAT), blimit))return(0);
       contents-=4; /* back up to the front of the count, as it is part of the data field */
       U_PMF_PTRSAV_SHIFT(BfH, &contents, 4 + (Elements * 2 * sizeof(U_FLOAT))); /* 4 byte count + 2 * 4bytes * Elements */
       if(Flags & U_BD_BlendFactorsV){
          if(IS_MEM_UNSAFE(contents, Elements * 2 * sizeof(U_FLOAT), blimit))return(0);
          U_PMF_PTRSAV_SHIFT(BfV, &contents, 0);
       }
    }
    else if(Flags & U_BD_BlendFactorsV){
       U_PMF_SERIAL_get(&contents, &Elements, 4, 1, U_LE);  /* starts with a 4 byte count*/
       if(IS_MEM_UNSAFE(contents, Elements * 2 * sizeof(U_FLOAT), blimit))return(0);
       contents-=4; /* back up to the front of the count, as it is part of the data field */
       U_PMF_PTRSAV_SHIFT(BfV, &contents, 0);
    }
    return(1);
}

/**
    \brief Get data from a U_PMF_LINEPATH object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Size       Bytes in Data
    \param  Data       Outline path
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.26, Microsoft name: EmfPlusLinePath Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_LINEPATH_get(const char *contents, int32_t *Size, const char **Data, const char *blimit){
    if(!contents || !Size  || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_LINEPATH), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Size, 4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_METAFILE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Type       
    \param  Size       Bytes in Data
    \param  Data       Various types of data, like an EMF metafile, WMF metafile, another EMF+ metafile
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.27, Microsoft name: EmfPlusMetafile Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_METAFILE_get(const char *contents, uint32_t *Type, uint32_t *Size, const char **Data, const char *blimit){
    if(!contents || !Type  || !Size  || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_METAFILE), blimit))return(0);
    U_PMF_SERIAL_get(&contents, &Type, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, &Size, 4, 1, U_LE);
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_PALETTE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      PaletteStyle flags
    \param  Elements   Members in the array
    \param  Colors     Palette data (array of colors)
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.28, Microsoft name: EmfPlusPalette Object
*/
int U_PMF_PALETTE_get(const char *contents, uint32_t *Flags, uint32_t *Elements, const char **Colors, const char *blimit){
    if(!contents || !Flags  || !Elements  || !Colors || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_PALETTE), blimit))return(0);
    U_PMF_SERIAL_get(&contents, &Flags,    4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, &Elements, 4, 1, U_LE);
    if(IS_MEM_UNSAFE(contents, *Elements*sizeof(U_RGBQUAD), blimit))return(0);
    U_PMF_PTRSAV_SHIFT(Colors, &contents, 0);
    return(1);
    
}

/**
    \brief Get data from a U_PMF_PATHGRADIENTBRUSHDATA object
    \return 1 on success, 0 on error
    \param  contents     Record from which to extract data
    \param  Pgbd         constant part of U_PMF_PATHGRADIENTBRUSHDATA object
    \param  Gradient     variable part of U_PMF_LINEARGRADIENTBRUSHDATA, Color Gradient with Elements members
    \param  Boundary     variable part of U_PMF_LINEARGRADIENTBRUSHDATA, U_PMF_BOUNDARYPATHDATA object if BrushDataPath bit set in Flag, else U_PMF_BOUNDARYPOINTDATA object
    \param  Data         variable part of U_PMF_LINEARGRADIENTBRUSHDATA, exact composition depends on Flags
    \param  blimit       one byte past the end of data

    EMF+ manual 2.2.2.29, Microsoft name: EmfPlusPathGradientBrushData Object

    Caller must check Data for possible memory access violations.

*/
int U_PMF_PATHGRADIENTBRUSHDATA_get(const char *contents, U_PMF_PATHGRADIENTBRUSHDATA *Pgbd, const char **Gradient, 
      const char **Boundary, const char **Data, const char *blimit){
    if(!contents || !Pgbd || !Gradient || !Boundary || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_PATHGRADIENTBRUSHDATA), blimit))return(0);
    uint32_t Size;
    U_PMF_SERIAL_get(&contents,  Pgbd,  	       4, 2, U_LE); /* Flags and WrapMode*/
    U_PMF_SERIAL_get(&contents,  &(Pgbd->CenterColor), 4, 1, U_XE);
    U_PMF_SERIAL_get(&contents,  &(Pgbd->Center),      4, 3, U_LE); /* Center and Elements */
    if(IS_MEM_UNSAFE(contents, Pgbd->Elements * sizeof(U_PMF_ARGB), blimit))return(0);
    U_PMF_PTRSAV_SHIFT(Gradient, &contents, Pgbd->Elements * sizeof(U_PMF_ARGB));
    U_PMF_PTRSAV_SHIFT(Boundary, &contents, 0);
    U_PMF_SERIAL_get(&contents,  &Size,                4, 1, U_LE); /* The first 4 bytes of the Boundary are always a size */
    if(Pgbd->Flags & U_BD_Path){ contents += Size;                   } // U_PMF_BOUNDARYPATHDATA
    else {                       contents += Size*2*sizeof(U_FLOAT); } // U_PMF_BOUNDARYPOINTDATA
    if(Pgbd->Flags & (U_BD_Transform |U_BD_PresetColors | U_BD_BlendFactorsH| U_BD_FocusScales)){ // optional data present
      if(contents >= blimit)return(0); // the size is variable but this must still hold
      U_PMF_PTRSAV_SHIFT(Data,     &contents, 0);
    }
    else { *Data = NULL; } // no optional data present
    return(1);
}

/**
    \brief Get data from a U_PMF_PATHGRADIENTBRUSHOPTIONALDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      bits set to indicate the presence of FillData and/or LineData
    \param  Matrix     Transformation matrix
    \param  Pattern    Blend Pattern
    \param  Data       Focus scales for the brush
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.30, Microsoft name: EmfPlusPathGradientBrushOptionalData Object
*/
int U_PMF_PATHGRADIENTBRUSHOPTIONALDATA_get(const char *contents, uint32_t Flags, U_PMF_TRANSFORMMATRIX *Matrix, 
      const char **Pattern, const char **Data, const char *blimit){
    int varsize;
    if(!contents || !Flags || !Matrix || !Pattern || !Data || !blimit){ return(0); }
    /* this structure is entirely optional */
    if(Flags & U_BD_Transform){
       if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_TRANSFORMMATRIX), blimit))return(0);
       U_PMF_SERIAL_get(&contents, Matrix, 4, 6, U_LE);
    }
    if(Flags &  (U_BD_PresetColors | U_BD_BlendFactorsH)){
       if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
       uint32_t Elements; 
       U_PMF_SERIAL_get(&contents, &Elements, 4, 1, U_LE);
       contents -= 4;
       varsize=(Elements * 4 * (Flags & U_BD_BlendFactorsH ? 2 :1));
       if(IS_MEM_UNSAFE(contents, varsize, blimit))return(0);
       U_PMF_PTRSAV_SHIFT(Pattern, &contents, varsize);
    }
    else { *Pattern=NULL; }
    if(Flags & U_BD_FocusScales){
       if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_FOCUSSCALEDATA), blimit))return(0);
       U_PMF_PTRSAV_SHIFT(Data, &contents, sizeof(U_PMF_FOCUSSCALEDATA));
    }
    else { *Data=NULL; }
    return(1);
}

/**
    \brief Get data from a U_PMF_PATHPOINTTYPE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      PathPointType flags
    \param  Type       PathPointType enumeration
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.31, Microsoft name: EmfPlusPathPointType Object

    Note:  order of 4bit fields appears to be shown in the LE column, not as
    documented in the BE column.
*/
int U_PMF_PATHPOINTTYPE_get(const char *contents, int *Flags, int *Type, const char *blimit){
    if(!contents || !Flags || !Type || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, 1, blimit))return(0);
    uint8_t tmp;
    memcpy(&tmp, contents, 1);
    *Flags =(tmp & U_PTP_MASK) >> U_PTP_SHIFT;
    *Type = (tmp & U_PPT_MASK);
    return(1);
}

/**
    \brief Get data from a U_PMF_PATHPOINTTYPERLE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Bezier     Set: Bezier curve, Clear: straight line
    \param  RL         Run Length
    \param  Ppt        PathPointType enumeration
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.32, Microsoft name: EmfPlusPathPointTypeRLE Object
*/
int U_PMF_PATHPOINTTYPERLE_get(const char *contents, int *Bezier, int *RL, int *Ppt, const char *blimit){
    if(!contents || !Bezier || !RL || !Ppt || !blimit){ return(0); }
    uint16_t tmp;
    if(IS_MEM_UNSAFE(contents, 2, blimit))return(0);
    U_PMF_SERIAL_get(&contents, &tmp, 2, 1, U_LE);
    *Bezier = tmp & U_PPF_BZ;
    *RL     = (tmp >> U_FF_SHFT_RL) & U_FF_MASK_RL;
    *Ppt    = (tmp >> U_FF_SHFT_PPT) & U_FF_MASK_PPT;
    return(1);
}

/**
    \brief Get data from a U_PMF_PENDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      PenData flags
    \param  Unit       UnitType enumeration
    \param  Width      Width in units set by Unit
    \param  Data       Optional pen data, exact composition depends on Flags
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.33, Microsoft name: EmfPlusPenData Object
*/
int U_PMF_PENDATA_get(const char *contents, uint32_t *Flags, uint32_t *Unit, U_FLOAT *Width, const char **Data, const char *blimit){
    if(!contents || !Flags || !Unit || !Width || !Data || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, 3*4, blimit))return(0);
    U_PMF_SERIAL_get(&contents, Flags, 4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Unit,  4, 1, U_LE);
    U_PMF_SERIAL_get(&contents, Width, 4, 1, U_LE);
    if(contents >= blimit)return(0); // variable data will extend farther, but this much at least must be true
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_PENOPTIONALDATA object
    \return 1 on success, 0 on error
    \param  contents       Record from which to extract data
    \param  Flags;         PenData Flags - indicated which of the many fields are present.
    \param  Matrix;        Transformation matrix
    \param  StartCap       LineCapType enumeration
    \param  EndCap         LineCapType enumeration
    \param  Join           LineJoinType enumeration
    \param  MiterLimit     Maximum (miter length / line width)
    \param  Style          LineStyle enumeration
    \param  DLCap          DashedLineCapType enumeration
    \param  DLOffset       Distance line start to first dash start
    \param  DLData         Dash and space widths
    \param  Alignment      PenAlignment enumeration
    \param  CmpndLineData  Compount Line (parallel lines drawn instead of one)
    \param  CSCapData      Custom start cap  
    \param  CECapData      Custom end cap
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.34, Microsoft name: EmfPlusPenOptionalData Object

    This object consists of a large number of optional and or variable values, which
    are returned, or not, depending on bits in Flags.
*/
int U_PMF_PENOPTIONALDATA_get(
    const char                *contents,
    uint32_t                   Flags,         // determines which fields are filled
    U_PMF_TRANSFORMMATRIX     *Matrix,
    int32_t                   *StartCap,
    int32_t                   *EndCap,
    uint32_t                  *Join,
    U_FLOAT                   *MiterLimit,
    int32_t                   *Style,
    int32_t                   *DLCap,
    U_FLOAT                   *DLOffset,
    const char               **DLData,
    int32_t                   *Alignment,
    const char               **CmpndLineData,
    const char               **CSCapData,
    const char               **CECapData,
    const char                *blimit){
    if(!contents  ||
       !Flags     || !Matrix     || !StartCap  || !EndCap        ||
       !Join      || !MiterLimit || !Style     || !DLCap         ||
       !DLOffset  || !DLData     || !Alignment || !CmpndLineData || 
       !CSCapData || !CECapData  || !blimit){ return(0); }

    if(Flags & U_PD_Transform){       if(IS_MEM_UNSAFE(contents, 4*6, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, Matrix,         4, 6, U_LE); 
    }
    if(Flags & U_PD_StartCap){        if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, StartCap,       4, 1, U_LE); 
    }
    if(Flags & U_PD_EndCap){          if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, EndCap,         4, 1, U_LE); 
    }
    if(Flags & U_PD_Join){            if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, Join,           4, 1, U_LE); 
    }
    if(Flags & U_PD_MiterLimit){      if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, MiterLimit,     4, 1, U_LE); 
    }
    if(Flags & U_PD_LineStyle){       if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, Style,          4, 1, U_LE); 
    }
    if(Flags & U_PD_DLCap){           if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, DLCap,          4, 1, U_LE); 
    }
    if(Flags & U_PD_DLOffset){        if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, DLOffset,       4, 1, U_LE); 
    }
    if(Flags & U_PD_DLData){          if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      if(IS_MEM_UNSAFE(contents, U_PMF_LEN_FLOATDATA(contents), blimit))return(0);
                                      U_PMF_PTRSAV_SHIFT(   DLData,         &contents, U_PMF_LEN_FLOATDATA(contents)); 
    }
    if(Flags & U_PD_NonCenter){       if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      U_PMF_SERIAL_get(&contents, Alignment,      4, 1, U_LE); }
    if(Flags & U_PD_CLData){          if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      if(IS_MEM_UNSAFE(contents, U_PMF_LEN_FLOATDATA(contents), blimit))return(0);
                                      U_PMF_PTRSAV_SHIFT(   CmpndLineData,  &contents, U_PMF_LEN_FLOATDATA(contents)); 
    }
    if(Flags & U_PD_CustomStartCap){  if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      if(IS_MEM_UNSAFE(contents, U_PMF_LEN_BYTEDATA(contents), blimit))return(0);
                                      U_PMF_PTRSAV_SHIFT(   CSCapData,      &contents, U_PMF_LEN_BYTEDATA(contents));  
    }
    if(Flags & U_PD_CustomEndCap){    if(IS_MEM_UNSAFE(contents, 4, blimit))return(0);
                                      if(IS_MEM_UNSAFE(contents, U_PMF_LEN_BYTEDATA(contents), blimit))return(0);
                                      U_PMF_PTRSAV_SHIFT(   CECapData,      &contents, U_PMF_LEN_BYTEDATA(contents));  
    }
    return(1);
}

/**
    \brief Get data from a U_PMF_POINT object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data.  On return position is offset by sizeof(U_PMF_POINT).
    \param  X          X coordinate
    \param  Y          Y coordinate
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.35, Microsoft name: EmfPlusPoint Object
*/
int U_PMF_POINT_get(const char **contents, U_FLOAT *X, U_FLOAT *Y, const char *blimit){
    if(!contents || !X || !Y || !blimit){ return(0); }
    int16_t tmp;
    if(IS_MEM_UNSAFE(*contents, 2*2, blimit))return(0);
    U_PMF_SERIAL_get(contents, &tmp, 2, 1, U_LE); *X = tmp;
    U_PMF_SERIAL_get(contents, &tmp, 2, 1, U_LE); *Y = tmp;
    return(1);
}

/**
    \brief Get data from a U_PMF_POINTF object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data.  On return position is offset by sizeof(U_PMF_POINTF).
    \param  X          X coordinate
    \param  Y          Y coordinate
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.36, Microsoft name: EmfPlusPointF Object
*/
int U_PMF_POINTF_get(const char **contents, U_FLOAT *X, U_FLOAT *Y, const char *blimit){
    if(!contents || !X || !Y || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(*contents, 4*2, blimit))return(0);
    U_PMF_SERIAL_get(contents, X, 4, 1, U_LE);
    U_PMF_SERIAL_get(contents, Y, 4, 1, U_LE);
    return(1);
}

/**
    \brief Get data from a U_PMF_POINTR object
    \return size in bytes traversed on success, 0 on error
    \param  contents   Record from which to extract data.  On return position is offset by returned size. 
    \param  X          X coordinate
    \param  Y          Y coordinate
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.37, Microsoft name: EmfPlusPointR Object
*/
int U_PMF_POINTR_get(const char **contents, U_FLOAT *X, U_FLOAT *Y, const char *blimit){
    if(!contents || !*contents || !X || !Y || !blimit){ return(0); }
    int size=0;

    if(     U_PMF_INTEGER7_get( contents, X, blimit)){ size +=1; } 
    else if(U_PMF_INTEGER15_get(contents, X, blimit)){ size +=2; }
    else {  return(0); }

    if(     U_PMF_INTEGER7_get( contents, Y, blimit)){ size +=1; } 
    else if(U_PMF_INTEGER15_get(contents, Y, blimit)){ size +=2; }
    else {  return(0); }

    return(size);
}

/**
    \brief Get data from a variable POINTS object, which may be U_PMF_POINTS, U_PMF_POINTF, or U_PMF_POINTR.
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      Record flags (bits U_PPF_C and U_PPF_P are referenced)
    \param  Elements   Number of points to retrieve.
    \param  Points     Caller must free.  Array of U_PMF_POINTF coordinates.
    \param  blimit     one byte past the end of data
    
    This function should never be called directly by end user code.
*/
int U_PMF_VARPOINTS_get(const char *contents, uint16_t Flags, int Elements, U_PMF_POINTF **Points, const char *blimit){
   int status = 0;
   if(!contents  || !Points || !Elements || !blimit){ return(status); }
   U_PMF_POINTF *pts = (U_PMF_POINTF *)malloc(Elements * sizeof(U_PMF_POINTF));
   if(!pts){ return(status); }
   *Points = pts;
   U_FLOAT XF, YF;
   U_FLOAT XFS, YFS;
   
   if(Flags & U_PPF_P){ 
      for(XFS = YFS = 0.0; Elements; Elements--, pts++){
         if(!U_PMF_POINTR_get(&contents, &XF, &YF, blimit))return(0); /* this should never happen */
         XFS      += XF; /* position relative to previous point, first point is always 0,0 */
         YFS      += YF;
         pts->X    = XFS;
         pts->Y    = YFS; 
      }
   }
   else if(Flags & U_PPF_C){
      for(XF = YF = 0.0; Elements; Elements--, pts++){
         if(!U_PMF_POINT_get(&contents, &XF, &XF, blimit))break; /* this should never happen */
         pts->X    = XF;
         pts->Y    = YF; 
      }
   }
   else {
      for(XF = YF = 0.0; Elements; Elements--, pts++){
         (void) U_PMF_POINTF_get(&contents, &XF, &YF, blimit); 
         pts->X    = XF;
         pts->Y    = YF; 
      }
   }
   if(Elements){ /* some error in the preceding */
      free(*Points);
      *Points = NULL;
   }
   else {
      status = 1;
   }
   return(status);
}

/**
    \brief Get data from a U_PMF_RECT object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  X          UL X value
    \param  Y          UL Y value
    \param  Width      Width
    \param  Height     Height
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.38, Microsoft name: EmfPlusRect Object
*/
int U_PMF_RECT_get(const char **contents, int16_t *X, int16_t *Y, int16_t *Width, int16_t *Height, const char *blimit){
    if(!contents || !X || !Y|| !Width || !Height){ return(0); }
    if(IS_MEM_UNSAFE(*contents, 2*4, blimit))return(0);
    U_PMF_SERIAL_get(contents, X,      2, 1, U_LE);
    U_PMF_SERIAL_get(contents, Y,      2, 1, U_LE);
    U_PMF_SERIAL_get(contents, Width,  2, 1, U_LE);
    U_PMF_SERIAL_get(contents, Height, 2, 1, U_LE);
    return(1);
}

/**
    \brief Get data from a U_PMF_RECTF object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  X          UL X value
    \param  Y          UL Y value
    \param  Width      Width
    \param  Height     Height
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.39, Microsoft name: EmfPlusRectF Object
*/
int U_PMF_RECTF_get(const char **contents, U_FLOAT *X, U_FLOAT *Y, U_FLOAT *Width, U_FLOAT *Height, const char *blimit){
    if(!contents || !X || !Y|| !Width || !Height){ return(0); }
    if(IS_MEM_UNSAFE(*contents, 4*4, blimit))return(0);
    U_PMF_SERIAL_get(contents, X,      4, 1, U_LE);
    U_PMF_SERIAL_get(contents, Y,      4, 1, U_LE);
    U_PMF_SERIAL_get(contents, Width,  4, 1, U_LE);
    U_PMF_SERIAL_get(contents, Height, 4, 1, U_LE);
    return(1);
}

/**
    \brief Get data from a variable RECTS object, which may be U_PMF_RECT or U_PMF_RECTF
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      Record flags (bit U_PPF_C is referenced)
    \param  Elements   Number of rects to retrieve.
    \param  Rects      Caller must free.  Array of U_PMF_RECTF coordinates.
    \param  blimit     one byte past the end of data

    Rects in record may be either U_PMF_RECT or U_PMF_RECTF, but this function always
    returns U_PMF_RECTF
*/
int U_PMF_VARRECTS_get(const char **contents, uint16_t Flags, int Elements, U_PMF_RECTF **Rects, const char *blimit){
   int16_t X16, Y16, Width, Height;
   if(!contents || !*contents || !Rects || !blimit){ return(0); }
   U_PMF_RECTF *rts = (U_PMF_RECTF *)malloc(Elements * sizeof(U_PMF_RECTF));
   if(!rts){
      *Rects = NULL;
      return(0);
   }
   
   *Rects = rts;
   if(Flags & U_PPF_C){
      if(IS_MEM_UNSAFE(*contents, Elements*sizeof(U_PMF_RECT), blimit)){
         free(rts);
         return(0);
      }
   }
   else {
      if(IS_MEM_UNSAFE(*contents, Elements*sizeof(U_PMF_RECT), blimit)){
         free(rts);
         return(0);
      }
   }
   for(; Elements; Elements--, rts++){
      if(Flags & U_PPF_C){
         (void) U_PMF_RECT_get(contents, &X16, &Y16, &Width, &Height, blimit);  
         rts->X      = X16;
         rts->Y      = Y16;
         rts->Width  = Width;
         rts->Height = Height;
      }
      else {
         (void) U_PMF_RECTF_get(contents, &(rts->X), &(rts->Y), &(rts->Width), &(rts->Height), blimit); 
      }
   }
   return(1);
}

/**
    \brief Get data from a U_PMF_REGIONNODE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Type       RegionNodeDataType
    \param  Data       Depending on Type: U_PMF_REGIONNODEPATH, U_PMF_RECTF, or U_PMF_REGIONNODECHILDNODES
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.40, Microsoft name: EmfPlusRegionNode Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_REGIONNODE_get(const char *contents, uint32_t *Type, const char **Data, const char *blimit){
    if(!contents || !Type || !Data || !blimit){ return(0); }
    /* Important!  This only checks the constant part, the caller must check that returned data doesn't exceed blimit */
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_REGIONNODE), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Type, 4, 1, U_LE);
    if(contents >= blimit)return(0); // returned Data is variable size, this much at least must be true
    U_PMF_PTRSAV_COND(Data, contents, !(*Type == U_RNDT_Empty || *Type == U_RNDT_Infinite ));
    return(1);
}

/**
    There is no U_PMF_REGIONNODECHILDNODES_get!
      
    The Region object is recursive allowing U_PMF_REGIONNODECHILDNODES -> 
       U_PMF_REGIONNODE -> U_PMF_REGIONNODECHILDNODES etc.
    So the data stored in each node must be handled as the tree is followed recursively.

    See U_PMF_REGIONNODECHILDNODES_print() and U_PMF_REGIONNODE_print() for an example.


    EMF+ manual 2.2.2.41, Microsoft name: EmfPlusRegionNodeChildNodes Object
*/

/**
    \brief Get data from a U_PMF_REGIONNODEPATH object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Size       Bytes in Data
    \param  Data       Boundary of region node
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.42, Microsoft name: EmfPlusRegionNodePath Object
*/
int U_PMF_REGIONNODEPATH_get(const char *contents, int32_t *Size, const char **Data, const char *blimit){
    if(!contents || !Size || !Data || !blimit){ return(0); }
    /* Important!  This only checks the constant part, the caller must check that returned data doesn't exceed blimit */
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_REGIONNODEPATH), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Size, 4, 1, U_LE);
    if(contents >= blimit)return(0); // returned Data is variable size, this much at least must be true
    U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
    return(1);
}

/**
    \brief Get data from a U_PMF_SOLIDBRUSHDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Color      Color of brush
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.43, Microsoft name: EmfPlusSolidBrushData Object
*/
int U_PMF_SOLIDBRUSHDATA_get(const char *contents, U_PMF_ARGB *Color, const char *blimit){
    if(!contents || !Color || !blimit){ return(0); }
    if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_SOLIDBRUSHDATA), blimit))return(0);
    U_PMF_SERIAL_get(&contents, Color, 4, 1, U_XE);
    return(1);
}

/**
    \brief Get data from a U_PMF_STRINGFORMATDATA object
    \return 1 on success, 0 on error
    \param  contents      Record from which to extract data
    \param  TabStopCount  Entries in TabStop array
    \param  RangeCount    Entries in CharRange array
    \param  TabStops      Array of tabstop locations
    \param  CharRange     Array of character ranges in the text
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.44, Microsoft name: EmfPlusStringFormatData Object
*/
int U_PMF_STRINGFORMATDATA_get(const char *contents, uint32_t TabStopCount, uint32_t RangeCount, 
      const U_FLOAT **TabStops, const U_PMF_CHARACTERRANGE **CharRange, const char *blimit){
   if(!contents || !TabStops|| !CharRange || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, (TabStopCount + 2*RangeCount)*4, blimit))return(0);
   *TabStops = NULL;
   if(TabStopCount > 0){ U_PMF_SERIAL_get(&contents, TabStops,  4, TabStopCount, U_LE); }
   *CharRange = NULL;
   if(RangeCount   > 0){ U_PMF_SERIAL_get(&contents, CharRange, 4, 2*RangeCount, U_LE); }
   return(1);
}

/**
    \brief Get data from a U_PMF_TEXTUREBRUSHDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Flags      BrushData flags
    \param  WrapMode   WrapMode enumeration
    \param  Data       Optional texture data
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.45, Microsoft name: EmfPlusTextureBrushData Object

    Caller must check Data for possible memory access violations.
*/
int U_PMF_TEXTUREBRUSHDATA_get(const char *contents, uint32_t *Flags, int32_t *WrapMode, const char **Data, const char *blimit){
   if(!contents || !Flags || !WrapMode || !Data || !blimit){ return(0); }
   /* Important!  This only checks the constant part, the caller must check that returned data doesn't exceed blimit */
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_TEXTUREBRUSHDATA), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Flags,    4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, WrapMode, 4, 1, U_LE);
   if(contents >= blimit)return(0); // returned Data is variable size, this much at least must be true
   U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
   return(1);
}

/**
    \brief Get data from a U_PMF_TEXTUREBRUSHOPTIONALDATA object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  HasImage   True if this object has an Image
    \param  Matrix     Transformation matrix, NULL if Flag BrushDataTransform is not set.
    \param  Image      Image that contains the texture.
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.46, Microsoft name: EmfPlusTextureBrushOptionalData Object

    Caller must check Image for possible memory access violations.
*/
int U_PMF_TEXTUREBRUSHOPTIONALDATA_get(const char *contents, int HasImage, U_PMF_TRANSFORMMATRIX *Matrix, 
      const char **Image, const char *blimit){
   if(!contents || !Image || !blimit){ return(0); }
   if(Matrix){
      if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_TRANSFORMMATRIX), blimit))return(0);
      U_PMF_SERIAL_get(&contents, Matrix,   4, 6, U_LE);
   }
   if(HasImage){
      if(contents >= blimit)return(0); // returned Data is variable size, this much at least must be true
      U_PMF_PTRSAV_COND(Image, contents, HasImage);
   }
   return(1);
}

/**
    \brief Get data from a U_PMF_TRANSFORMMATRIX object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Matrix     Transformation matrix, present if Flag BrushDataTransform is set.
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.2.47, Microsoft name: EmfPlusTransformMatrix Object
*/
int U_PMF_TRANSFORMMATRIX_get(const char *contents, U_PMF_TRANSFORMMATRIX *Matrix, const char *blimit){
   if(!contents || !Matrix || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_TRANSFORMMATRIX), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Matrix, 4, 6, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_BLUR object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Radius     Blur radius in pixels
    \param  ExpandEdge 1: expand bitmap by Radius; 0: bitmap size unchanged
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.1, Microsoft name: BlurEffect Object
*/
int U_PMF_IE_BLUR_get(const char *contents, U_FLOAT *Radius, uint32_t *ExpandEdge, const char *blimit){
   if(!contents || !Radius || !ExpandEdge || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_BLUR), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Radius,     4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, ExpandEdge, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_BRIGHTNESSCONTRAST object
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Brightness  -255 to 255, 0 is unchanged, positive increases, negative decreases
    \param  Contrast    -100 to 100, 0 is unchanged, positive increases, negative decreases
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.2, Microsoft name: BrightnessContrastEffect Object
*/
int U_PMF_IE_BRIGHTNESSCONTRAST_get(const char *contents, int32_t *Brightness, int32_t *Contrast, const char *blimit){
   if(!contents || !Brightness || !Contrast || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_BRIGHTNESSCONTRAST), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Brightness, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Contrast,   4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_COLORBALANCE object
    \return 1 on success, 0 on error
    \param  contents     Record from which to extract data
    \param  CyanRed      -100 to 100, 0 is unchanged, positive increases Red   & decreases Cyan,    negative is opposite
    \param  MagentaGreen -100 to 100, 0 is unchanged, positive increases Green & decreases Magenta, negative is opposite
    \param  YellowBlue   -100 to 100, 0 is unchanged, positive increases Blue  & decreases Yellow,  negative is opposite
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.3, Microsoft name: ColorBalanceEffect Object
*/
int U_PMF_IE_COLORBALANCE_get(const char *contents, int32_t *CyanRed, int32_t *MagentaGreen, int32_t *YellowBlue, const char *blimit){
   if(!contents || !CyanRed || !MagentaGreen || !YellowBlue || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_COLORBALANCE), blimit))return(0);
   U_PMF_SERIAL_get(&contents, CyanRed,      4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, MagentaGreen, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, YellowBlue,   4, 1, U_LE);
   return(1);
}


/**
    \brief Get data from a U_PMF_IE_COLORCURVE object
    \return 1 on success, 0 on error
    \param  contents     Record from which to extract data
    \param  Adjust       CurveAdjustment enumeration
    \param  Channel      CurveChannel enumeration
    \param  Intensity    adjustment to apply.  "Adjust" determines what field this is and range values.
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.4, Microsoft name: ColorCurveEffect Object
*/
int U_PMF_IE_COLORCURVE_get(const char *contents, uint32_t *Adjust, uint32_t *Channel, int32_t *Intensity, const char *blimit){
   if(!contents || !Adjust || !Channel || !Intensity || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_COLORCURVE), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Adjust,    4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Channel,   4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Intensity, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_COLORLOOKUPTABLE object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  BLUT       Blue  color lookup table
    \param  GLUT       Green color lookup table
    \param  RLUT       Red   color lookup table
    \param  ALUT       Alpha color lookup table
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.5, Microsoft name: ColorLookupTableEffect Object
*/
int U_PMF_IE_COLORLOOKUPTABLE_get(const char *contents, 
      const uint8_t **BLUT, const uint8_t **GLUT, const uint8_t **RLUT, const uint8_t **ALUT, const char *blimit){
   if(!contents || !BLUT || !GLUT || !RLUT || !ALUT || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_COLORLOOKUPTABLE) + 4 * 256, blimit))return(0);
   U_PMF_PTRSAV_SHIFT((const char **)BLUT, &contents, 256);
   U_PMF_PTRSAV_SHIFT((const char **)GLUT, &contents, 256);
   U_PMF_PTRSAV_SHIFT((const char **)RLUT, &contents, 256);
   U_PMF_PTRSAV_SHIFT((const char **)ALUT, &contents, 256);    
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_COLORMATRIX object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Matrix     5 x 5 color transformation matrix, First 4 rows are [{4 multiplier values},0.0] for R,G,B,A, last Row is [{4 color translation valuess}, 1.0]
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.6, Microsoft name: ColorMatrixEffect Object
*/
int U_PMF_IE_COLORMATRIX_get(const char *contents, U_PMF_IE_COLORMATRIX *Matrix, const char *blimit){
   if(!contents || !Matrix || !blimit){ return(0); }
   /* Important!  This only checks the constant part, the caller must check that returned data doesn't exceed blimit */
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_COLORMATRIX), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Matrix, 4, 5*5, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_HUESATURATIONLIGHTNESS object
    \return 1 on success, 0 on error
    \param  contents     Record from which to extract data
    \param  Hue          -180 to 180, 0 is unchanged
    \param  Saturation   -100 to 100, 0 is unchanged
    \param  Lightness    -100 to 100, 0 is unchanged
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.7, Microsoft name: HueSaturationLightnessEffect Object
*/
int U_PMF_IE_HUESATURATIONLIGHTNESS_get(const char *contents, int32_t *Hue, int32_t *Saturation, int32_t *Lightness, const char *blimit){
   if(!contents || !Hue || !Saturation || !Lightness || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_HUESATURATIONLIGHTNESS), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Hue,        4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Saturation, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Lightness,  4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_LEVELS object
    \return 1 on success, 0 on error
    \param  contents     Record from which to extract data
    \param  Highlight    0 to 100, 100 is unchanged
    \param  Midtone      -100 to 100, 0 is unchanged
    \param  Shadow       0 to 100, 0 is unchanged
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.8, Microsoft name: LevelsEffect Object
*/
int U_PMF_IE_LEVELS_get(const char *contents, int32_t *Highlight, int32_t *Midtone, int32_t *Shadow, const char *blimit){
   if(!contents || !Highlight || !Midtone || !Shadow || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_LEVELS), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Highlight, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Midtone,   4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Shadow,    4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_REDEYECORRECTION object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Elements   Number of members in Rects
    \param  Rects      Caller must free.  Pointer to memory holding an array of U_RECTL.
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.9, Microsoft name: RedEyeCorrectionEffect Object
*/
int U_PMF_IE_REDEYECORRECTION_get(const char *contents, int32_t *Elements, U_RECTL **Rects, const char *blimit){
   if(!contents || !Elements || !Rects || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_REDEYECORRECTION), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   if(IS_MEM_UNSAFE(contents, *Elements * 4, blimit))return(0);
   *Rects = (U_RECTL *) malloc(*Elements * sizeof(U_RECTL));
   if(!*Rects){ return(0); }
   U_PMF_SERIAL_get(&contents, *Rects, 4, *Elements * 4, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_SHARPEN object
    \return 1 on success, 0 on error
    \param  contents   Record from which to extract data
    \param  Radius     Sharpening radius in pixels
    \param  Sharpen    0 to 100, 0 is unchanged
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.10, Microsoft name: SharpenEffect Object
*/
int U_PMF_IE_SHARPEN_get(const char *contents, U_FLOAT *Radius, int32_t *Sharpen, const char *blimit){
   if(!contents || !Radius || !Sharpen || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_SHARPEN), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Radius,  4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Sharpen, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMF_IE_TINT object
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Hue         -180 to 180, [positive==clockwise] rotation in degrees starting from blue
    \param  Amount      -100 [add black] to 100[add white], 0 is unchanged.  Change in hue on specified axis
    \param  blimit     one byte past the end of data

    EMF+ manual 2.2.3.11, Microsoft name: TintEffect Object
*/
int U_PMF_IE_TINT_get(const char *contents, int32_t *Hue, int32_t *Amount, const char *blimit){
   if(!contents || !Hue || !Amount || !blimit){ return(0); }
   if(IS_MEM_UNSAFE(contents, sizeof(U_PMF_IE_TINT), blimit))return(0);
   U_PMF_SERIAL_get(&contents, Hue,    4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Amount, 4, 1, U_LE);
   return(1);
}

/*

   end of U_PMF_*_get() functions 
   =====================================================================================
   start of U_PMR_*_get() functions 

      These functions all assume that the size field in the common EMF+ header has already
      been checked, so that the extent the record claims exists in the data read in for the file.
      Consequently none of them takes a blimit parameter.  They generate a new one from the
      header size field and contents if needed.

*/

int U_PMR_common_stack_get(const char *contents, U_PMF_CMN_HDR *Header, uint32_t *StackID){
   if(!contents || !StackID){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_RESTORE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   U_PMF_SERIAL_get(&contents, StackID, 4, 1, U_LE);
   return(1);
}

/* for records that have a type but no associated flag bits or data */
int U_PMR_common_header_get(const char *contents, U_PMF_CMN_HDR *Header){
   /* memory access safe, only uses the common header */
   if(!contents){ return(0); }
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_OFFSETCLIP record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header (ignore flags)
    \param  dX          horizontal translation offset to apply to clipping region
    \param  dY          vertical   translation offset to apply to clipping region

    EMF+ manual 2.3.1.1, Microsoft name: EmfPlusOffsetClip Record,  Index 0x35
*/
int U_PMR_OFFSETCLIP_get(const char *contents, U_PMF_CMN_HDR *Header,
      U_FLOAT *dX, U_FLOAT *dY){
   if(!contents){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_OFFSETCLIP))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   U_PMF_SERIAL_get(&contents, dX, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, dY, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_RESETCLIP record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header (ignore flags)

    EMF+ manual 2.3.1.2, Microsoft name: EmfPlusResetClip Record, Index 0x31
*/
int U_PMR_RESETCLIP_get(const char *contents, U_PMF_CMN_HDR *Header){
   if(!contents){ return(0); }
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETCLIPPATH record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  CMenum      CombineMode enumeration..
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)

    EMF+ manual 2.3.1.3, Microsoft name: EmfPlusSetClipPath Record, Index 0x33
*/
int U_PMR_SETCLIPPATH_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PathID, int *CMenum){
   if(!contents || !PathID || !CMenum){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETCLIPPATH))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *CMenum  = (lclHeader.Flags >> U_FF_SHFT_CM4) & U_FF_MASK_CM4;
   *PathID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   return(1);
}

/**
    \brief Get data from a U_PMR_SETCLIPRECT record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header (ignore flags)
    \param  CMenum      Combine mode enumeration.
    \param  Rect        Rectangle used with CombineMode enumeration from Header.Flags

    EMF+ manual 2.3.1.4, Microsoft name: EmfPlusSetClipRect Record, Index 0x32
*/
int U_PMR_SETCLIPRECT_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *CMenum,
      U_PMF_RECTF *Rect){
   if(!contents || !CMenum || !Rect ){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETCLIPRECT))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *CMenum  = (lclHeader.Flags >> U_FF_SHFT_CM4) & U_FF_MASK_CM4;
   U_PMF_SERIAL_get(&contents, Rect, 4, 4, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETCLIPREGION record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  CMenum      CombineMode enumeration..
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)

    EMF+ manual 2.3.1.5, Microsoft name: EmfPlusSetClipRegion Record, Index 0x34
*/
int U_PMR_SETCLIPREGION_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PathID, int *CMenum){
   if(!contents || !PathID || !CMenum){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETCLIPREGION))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *CMenum  = (lclHeader.Flags >> U_FF_SHFT_CM4) & U_FF_MASK_CM4;
   *PathID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   return(1);
}

/**
    \brief Get data from a U_PMR_COMMENT record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header (ignore flags)
    \param  Data        Private data, may be anything

    EMF+ manual 2.3.2.1, Microsoft name: EmfPlusComment Record, Index 0x03
    
    Caller must check Data for possible memory access violations.
*/
int U_PMR_COMMENT_get(const char *contents, U_PMF_CMN_HDR *Header,
      const char **Data){
   if(!contents || !Data){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_COMMENT))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
   return(1);
}

/**
    \brief Get data from a U_PMR_ENDOFFILE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header  (ignore flags)

    EMF+ manual 2.3.3.1, Microsoft name: EmfPlusEndOfFile Record, Index 0x02
*/
int U_PMR_ENDOFFILE_get(const char *contents, U_PMF_CMN_HDR *Header){
   if(!contents){ return(0); }
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_GETDC record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header  (ignore flags)

    EMF+ manual 2.3.3.2, Microsoft name: EmfPlusGetDC Record, Index 0x04
*/
int U_PMR_GETDC_get(const char *contents, U_PMF_CMN_HDR *Header){
   if(!contents){ return(0); }
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_HEADER record
    \return 1 on success, 0 on error
    \param  contents     Record from which to extract data
    \param  Header       Common header  (ignore flags)
    \param  Version      EmfPlusGraphicsVersion object
    \param  IsDual       set = Dual-mode file, clear= EMF+ only file.
    \param  IsVideo      set = video device, clear= printer.  Ignore all other bits.
    \param  LogicalDpiX  Horizontal resolution reference device in DPI
    \param  LogicalDpiY  Vertical   resolution reference device in DPI

    EMF+ manual 2.3.3.3, Microsoft name: EmfPlusHeader Record, Index 0x01
*/
int U_PMR_HEADER_get(const char *contents, U_PMF_CMN_HDR *Header,
      U_PMF_GRAPHICSVERSION *Version, int *IsDual, int *IsVideo, uint32_t *LogicalDpiX, uint32_t *LogicalDpiY){
   if(!contents || !Version || !IsDual || !IsVideo || !LogicalDpiX || !LogicalDpiY){ return(0); }
   uint32_t tmp;

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_HEADER))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *IsDual = (lclHeader.Flags & U_PPF_DM ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, Version,     4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, &tmp,        4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, LogicalDpiX, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, LogicalDpiY, 4, 1, U_LE);
   *IsVideo = (tmp & U_PPF_VIDEO ? 1 : 0 );
   return(1);
}

/**
    \brief Get data from a U_PMR_CLEAR record
    \return 1 on success, 0 on error
    \param  contents     Record from which to extract data
    \param  Header       Common header  (ignore flags)
    \param  Color        Erase everything preceding, set background ARGB color.

    EMF+ manual 2.3.4.1, Microsoft name: EmfPlusClear Record, Index 0x09
*/
int U_PMR_CLEAR_get(const char *contents, U_PMF_CMN_HDR *Header,
      U_PMF_ARGB *Color){
   if(!contents || !Color){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_CLEAR))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   U_PMF_SERIAL_get(&contents, Color, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWARC record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  Start       Start angle, >=0.0, degrees clockwise from 3:00
    \param  Sweep       Sweep angle, -360<= angle <=360, degrees clockwise from Start
    \param  Rect        Caller must free.  Bounding rectangle.  Coordinate type set by ctype.

    EMF+ manual 2.3.4.2, Microsoft name: EmfPlusDrawArc Record, Index 0x12
*/
int U_PMR_DRAWARC_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PenID, int *ctype, 
      U_FLOAT *Start, U_FLOAT *Sweep,
      U_PMF_RECTF *Rect){
   if(!contents || !PenID || !ctype || !Start || !Sweep || !Rect){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWARC))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *ctype = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *PenID = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, Start, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Sweep, 4, 1, U_LE);
   U_PMF_RECTF *Rects = NULL;
   if(!U_PMF_VARRECTS_get(&contents, lclHeader.Flags, 1, &Rects, blimit))return(0);
   memcpy(Rect,Rects,sizeof(U_PMF_RECTF));
   free(Rects);
   return(1);
}


/**
    \brief Get data from a U_PMR_DRAWBEZIERS record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  RelAbs      Set: Coordinates are relative; Clear: Coordinates are absolute and their type is set by ctype
    \param  Elements    Number of members in the Data array
    \param  Points      Caller must free.  Array of U_POINT_F = Sequence of points to connect.  Coordinate type set by ctype and RelAbs.

    EMF+ manual 2.3.4.3, Microsoft name: EmfPlusDrawBeziers Record, Index 0x19
*/
int U_PMR_DRAWBEZIERS_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PenID, int *ctype, int *RelAbs, 
      uint32_t *Elements, 
      U_PMF_POINTF **Points){
   if(!contents || !PenID || !ctype || !RelAbs || !Elements || !Points){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWBEZIERS))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *RelAbs = (lclHeader.Flags & U_PPF_P ? 1 : 0 );
   *PenID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   int status = U_PMF_VARPOINTS_get(contents, lclHeader.Flags, *Elements, Points, blimit );
   return(status);
}

/**
    \brief Get data from a U_PMR_DRAWCLOSEDCURVE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  RelAbs      Set: Coordinates are relative; Clear: Coordinates are absolute and their type is set by ctype
    \param  Tension     Controls splines, 0 is straight line, >0 is curved
    \param  Elements    Number of members in the Data array
    \param  Points      Caller must free.  Array of U_POINT_F = Sequence of points to connect.  Coordinate type set by ctype and RelAbs.

    EMF+ manual 2.3.4.4, Microsoft name: EmfPlusDrawClosedCurve Record, Index 0x17
*/
int U_PMR_DRAWCLOSEDCURVE_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PenID, int *ctype, int *RelAbs,
      U_FLOAT *Tension, uint32_t *Elements,
      U_PMF_POINTF **Points){
   if(!contents || !PenID || !ctype || !RelAbs || !Tension || !Elements || !Points){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWCLOSEDCURVE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *RelAbs = (lclHeader.Flags & U_PPF_P ? 1 : 0 );
   *PenID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, Tension,  4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   U_PMF_VARPOINTS_get(contents, lclHeader.Flags, *Elements, Points, blimit);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWCURVE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  Tension     Controls splines, 0 is straight line, >0 is curved
    \param  Offset      Element in Points that is the spline's starting point
    \param  NSegs       Number of segments
    \param  Elements    Number of members in Data array
    \param  Points      Caller must free.  Array of U_POINT_F = Sequence of points to connect.  Coordinate type set by ctype and RelAbs.

    EMF+ manual 2.3.4.5, Microsoft name: EmfPlusDrawCurve Record, Index 0x18
*/
int U_PMR_DRAWCURVE_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PenID, int *ctype,
      U_FLOAT *Tension, uint32_t *Offset, uint32_t *NSegs, uint32_t *Elements,
      U_PMF_POINTF **Points){
   if(!contents || !PenID || !ctype || !Tension || !Offset || !NSegs || !Elements || !Points){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWCURVE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *PenID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, Tension,  4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Offset,   4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, NSegs,    4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   U_PMF_VARPOINTS_get(contents, lclHeader.Flags, *Elements, Points, blimit);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWDRIVERSTRING record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  FontID      U_PMF_FONT object in the EMF+ object table (0-63, inclusive)
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: index of U_PMF_BRUSH object in EMF+ object table.
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depends on Flags bit0
    \param  DSOFlags    DriverStringOptions flags
    \param  HasMatrix   If 1 record contains a TransformMatrix field, if 0 it does not.
    \param  Elements    Number of members in Glyphs and Positions array
    \param  Glyphs      Caller must free.  If U_DSO_CmapLookup is set in DSOFlags this is an array of UTF16LE characters, otherwise, it is an array of indices into the U_PMF_FONT object indexed by Object_ID in flags.
    \param  Points      Caller must free.  Coordinates of each member of Glyphs.  U_DSO_RealizedAdvance set in DSOFlags Relative then positions are calculated relative to the first glyph which is stored in Positions, otherwise, all glyph positions are stored in Positions.
    \param  Matrix      Caller must free.  Transformation to apply to Glyphs & Positions. Present if HasMatrix is 1

    EMF+ manual 2.3.4.6, Microsoft name: EmfPlusDrawDriverString Record, Index 0x36
*/
int U_PMR_DRAWDRIVERSTRING_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *FontID, int *btype,
      uint32_t *BrushID, uint32_t *DSOFlags, uint32_t *HasMatrix, uint32_t *Elements,
      uint16_t **Glyphs, U_PMF_POINTF **Points, U_PMF_TRANSFORMMATRIX **Matrix){
   if(!contents || !FontID || !btype || !BrushID || 
      !DSOFlags || !HasMatrix || !Elements || !Glyphs || !Points || !Matrix){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWDRIVERSTRING))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *btype  = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *FontID = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, BrushID,   4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   U_PMF_SERIAL_get(&contents, DSOFlags,  4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, HasMatrix, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Elements,  4, 1, U_LE);
   if(IS_MEM_UNSAFE(contents, *Elements*2 + *Elements*2*4 + 24, blimit))return(0);
   if(!U_PMF_SERIAL_array_copy_get(&contents, (void **)Glyphs, 2, *Elements,    U_LE, (*DSOFlags & U_DSO_CmapLookup))){      return(0); }
   if(!U_PMF_SERIAL_array_copy_get(&contents, (void **)Points, 4, *Elements *2, U_LE, (*DSOFlags & U_DSO_RealizedAdvance))){ return(0); }
   if(!U_PMF_SERIAL_array_copy_get(&contents, (void **)Matrix, 4, 6,            U_LE, (*HasMatrix))){                        return(0); }
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWELLIPSE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  Rect        Caller must free.  Bounding rectangle.  Coordinate type set by ctype.

    EMF+ manual 2.3.4.7, Microsoft name: EmfPlusDrawEllipse Record, Index 0x0F
*/
int U_PMR_DRAWELLIPSE_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PenID, int *ctype, 
      U_PMF_RECTF *Rect){
   if(!contents || !PenID || !ctype || !Rect){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWELLIPSE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *PenID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, Rect,  4, 4, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWIMAGE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  ImgID       U_PMF_IMAGE object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  ImgAttrID   index of a U_PMF_IMAGEATTRIBUTES object in the object table
    \param  SrcUnit     UnitType enumeration
    \param  SrcRect     Region of image 
    \param  DstRect     Destination rectangle for image.  Coordinate type set by ctype.

    EMF+ manual 2.3.4.8, Microsoft name: EmfPlusDrawImage Record, Index 0x1A
*/
int U_PMR_DRAWIMAGE_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *ImgID, int *ctype,
      uint32_t *ImgAttrID, int32_t *SrcUnit, U_PMF_RECTF *SrcRect,
      U_PMF_RECTF *DstRect){
   if(!contents || !ImgID || !ctype || !ImgAttrID || !SrcUnit || !SrcRect || !DstRect){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWIMAGE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *ImgID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, ImgAttrID, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, SrcUnit,   4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, SrcRect,   4, 4, U_LE);
   U_PMF_SERIAL_get(&contents, DstRect,   4, 4, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWIMAGEPOINTS record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  ImgID       U_PMF_IMAGE object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  etype       Set: effect from previous U_PMR_SERIALIZABLEOBJECT record will be applied; Clear:  no effect applied
    \param  RelAbs      Set: Data is relative, Clear: if it is absolute
    \param  ImgAttrID   EmfPlusImageAttributes object 
    \param  SrcUnit     UnitType enumeration
    \param  SrcRect     Region of image 
    \param  Elements    Number of members in Points, must be 3
    \param  Points      Caller must free.  3 points of a parallelogram..  Coordinate type set by ctype and RelAbs.

    EMF+ manual 2.3.4.9, Microsoft name: EmfPlusDrawImagePoints Record, Index 0x1B
*/
int U_PMR_DRAWIMAGEPOINTS_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *ImgID, int *ctype, int *etype, int *RelAbs,
      uint32_t *ImgAttrID, int32_t *SrcUnit, U_PMF_RECTF *SrcRect, uint32_t *Elements, 
      U_PMF_POINTF **Points){
   if(!contents || !ImgID || !ctype || !etype || !RelAbs || !ImgAttrID || !SrcUnit || !Elements || !Points){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWIMAGEPOINTS))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *etype  = (lclHeader.Flags & U_PPF_E ? 1 : 0 );
   *RelAbs = (lclHeader.Flags & U_PPF_P ? 1 : 0 );
   *ImgID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, ImgAttrID, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, SrcUnit,   4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, SrcRect,   4, 4, U_LE);
   U_PMF_SERIAL_get(&contents, Elements,  4, 1, U_LE);
   U_PMF_VARPOINTS_get(contents, lclHeader.Flags, *Elements, Points, blimit);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWLINES record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  dtype       Set: path must be closed, Clear: path is open
    \param  RelAbs      Set: Coordinates are relative; Clear: Coordinates are absolute and their type is set by ctype
    \param  Elements    Number of members in Points
    \param  Points      Caller must free.  Array of U_POINT_F = Sequence of points to connect.  Coordinate type set by ctype and RelAbs.

    EMF+ manual 2.3.4.10, Microsoft name: EmfPlusDrawLines Record, Index 0x0D
*/
int U_PMR_DRAWLINES_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PenID, int *ctype, int *dtype, int *RelAbs,
      uint32_t *Elements,
      U_PMF_POINTF **Points){
   if(!contents || !PenID || !ctype || !dtype || !RelAbs || !Elements || !Points){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWLINES))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *dtype  = (lclHeader.Flags & U_PPF_D ? 1 : 0 );
   *RelAbs = (lclHeader.Flags & U_PPF_P ? 1 : 0 );
   *PenID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   U_PMF_VARPOINTS_get(contents, lclHeader.Flags, *Elements, Points, blimit);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWPATH record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)

    EMF+ manual 2.3.4.11, Microsoft name: EmfPlusDrawPath Record, Index 0x15
*/
int U_PMR_DRAWPATH_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PathID, uint32_t *PenID){
   if(!contents || !PathID || !PenID){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWPATH))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *PathID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, PenID, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWPIE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  Start       Start angle, >=0.0, degrees clockwise from 3:00
    \param  Sweep       Sweep angle, -360<= angle <=360, degrees clockwise from Start
    \param  Rect        Caller must free.  Bounding rectangle.  Coordinate type set by ctype.

    EMF+ manual 2.3.4.12, Microsoft name: EmfPlusDrawPie Record, Index 0x0D
*/
int U_PMR_DRAWPIE_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PenID, int *ctype,
      U_FLOAT *Start, U_FLOAT *Sweep,
      U_PMF_RECTF *Rect){
   if(!contents || !PenID || !ctype || !Start || !Sweep || !Rect){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWPIE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *ctype = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *PenID = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, Start, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Sweep, 4, 1, U_LE);
   U_PMF_RECTF *Rects = NULL;
   if(!U_PMF_VARRECTS_get(&contents, lclHeader.Flags, 1, &Rects, blimit))return(0);
   memcpy(Rect,Rects,sizeof(U_PMF_RECTF));
   free(Rects);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWRECTS record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PenID       U_PMF_PEN object in the EMF+ object table (0-63, inclusive)
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  Elements    Number of members in Rects
    \param  Rects       Caller must free.  Array of U_PMF_RECTF rectangles to draw.

    EMF+ manual 2.3.4.13, Microsoft name: EmfPlusDrawRects Record, Index 0x0B
    
    Rects in record may be either U_PMF_RECT or U_PMF_RECTF, but this function always
    returns U_PMF_RECTF
*/
int U_PMR_DRAWRECTS_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PenID, int *ctype,
      uint32_t *Elements,
      U_PMF_RECTF **Rects){
   if(!contents || !PenID || !Elements || !Rects){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWPIE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *PenID =  (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   U_PMF_VARRECTS_get(&contents, lclHeader.Flags, *Elements, Rects, blimit);
   return(1);
}

/**
    \brief Get data from a U_PMR_DRAWSTRING record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  FontID      U_PMF_FONT object in the EMF+ object table (0-63, inclusive)
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: index of U_PMF_BRUSH object in EMF+ object table.
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depending on btype.
    \param  FormatID    U_PMF_STRINGFORMAT object in EMF+ Object Table.
    \param  Elements    Number of characters in the string.
    \param  Rect        String's bounding box.
    \param  String      Caller must free.  Array of UFT-16LE unicode characters. 

    EMF+ manual 2.3.4.14, Microsoft name: EmfPlusDrawString Record, Index 0x1C
*/
int U_PMR_DRAWSTRING_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *FontID, int *btype,
      uint32_t *BrushID, uint32_t *FormatID, uint32_t *Elements, U_PMF_RECTF *Rect,
      uint16_t **String){
   if(!contents || !FontID || !btype || !BrushID || !FormatID || !Elements || !String){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWPIE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *btype  = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *FontID = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, BrushID,  4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   U_PMF_SERIAL_get(&contents, FormatID, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Rect,     4, 4, U_LE);
   if(IS_MEM_UNSAFE(contents, *Elements * 2, blimit))return(0);
   if(!U_PMF_SERIAL_array_copy_get(&contents, (void **)String, 2, *Elements, U_XE, 1)){ return(0); }
   return(1);
}

/**
    \brief Get data from a U_PMR_FILLCLOSEDCURVE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: is index of U_PMF_BRUSH object in EMF+ object table.
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  ftype       Set: winding fill; Clear: alternate fill
    \param  RelAbs      Set: Coordinates are relative; Clear: Coordinates are absolute and their type is set by ctype
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depending on btype.
    \param  Tension     Controls splines, 0 is straight line, >0 is curved
    \param  Elements    Number of members in Points
    \param  Points      Caller must free.  Array of U_POINT_F = Sequence of points to connect.  Coordinate type set by ctype and RelAbs.

    EMF+ manual 2.3.4.15, Microsoft name: EmfPlusFillClosedCurve Record, Index 0x16
*/
int U_PMR_FILLCLOSEDCURVE_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *btype, int *ctype, int *ftype, int *RelAbs,
      uint32_t *BrushID, U_FLOAT *Tension, uint32_t *Elements,
      U_PMF_POINTF **Points){
   if(!contents || !btype || !ctype || !ftype || !RelAbs || !BrushID || !Tension || !Elements || !Points){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWLINES))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *btype  = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *ftype  = (lclHeader.Flags & U_PPF_F ? 1 : 0 );
   *RelAbs = (lclHeader.Flags & U_PPF_P ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, BrushID,  4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   U_PMF_SERIAL_get(&contents, Tension,  4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   U_PMF_VARPOINTS_get(contents, lclHeader.Flags, *Elements, Points, blimit);
   return(1);
}

/**
    \brief Get data from a U_PMR_FILLELLIPSE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: is index of U_PMF_BRUSH object in EMF+ object table.
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depending on btype.
    \param  Rect        Caller must free.  Bounding box for elliptical pie segment being drawn.  Coordinate type set by ctype.

    EMF+ manual 2.3.4.16, Microsoft name: EmfPlusFillEllipse Record, Index 0x0E
*/
int U_PMR_FILLELLIPSE_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *btype, int *ctype,
      uint32_t *BrushID,
      U_PMF_RECTF *Rect){
   if(!contents || !btype || !ctype || !BrushID || !Rect){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_FILLELLIPSE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *btype  = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, BrushID, 4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   U_PMF_SERIAL_get(&contents, Rect,    4, 4, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_FILLPATH record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: is index of U_PMF_BRUSH object in EMF+ object table.
    \param  PathID      U_PMF_PATH object in the EMF+ object table (0-63, inclusive)
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depending on btype.

    EMF+ manual 2.3.4.17, Microsoft name: EmfPlusFillPath Record, Index 0x14 

    Note: U_PMF_FILLPATHOBJ is the object, U_PMF_FILLPATH is the file record
*/
int U_PMR_FILLPATH_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *PathID, int *btype,
      uint32_t *BrushID){
   if(!contents || !PathID || !btype || !BrushID){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_FILLPATH))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *btype  = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *PathID = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, BrushID, 4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   return(1);
}

/**
    \brief Get data from a U_PMR_FILLPIE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: is index of U_PMF_BRUSH object in EMF+ object table.
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depending on btype.
    \param  Start       Start angle, >=0.0, degrees clockwise from 3:00
    \param  Sweep       Sweep angle, -360<= angle <=360, degrees clockwise from Start
    \param  Rect        Bounding box for elliptical pie segment being filled.  Coordinate type set by ctype.

    EMF+ manual 2.3.4.18, Microsoft name: EmfPlusFillPie Record, Index 0x10
*/
int U_PMR_FILLPIE_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *btype, int *ctype,
      uint32_t *BrushID, U_FLOAT *Start, U_FLOAT *Sweep,
      U_PMF_RECTF *Rect){
   if(!contents || !btype || !ctype || !BrushID || !Start || !Sweep || !Rect){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_FILLPIE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *btype  = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, BrushID, 4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   U_PMF_SERIAL_get(&contents, Start,   4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Sweep,   4, 1, U_LE);
   U_PMF_RECTF *Rects = NULL;
   if(!U_PMF_VARRECTS_get(&contents, lclHeader.Flags, 1, &Rects, blimit))return(0);
   memcpy(Rect,Rects,sizeof(U_PMF_RECTF));
   free(Rects);
   return(1);
}

/**
    \brief Get data from a U_PMR_FILLPOLYGON record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: is index of U_PMF_BRUSH object in EMF+ object table.
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  RelAbs      Set: U_PMF_PathPointTypeRLE and/or U_PMF_PathPointType objects; Clear: only U_PMF_PathPointType
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depending on btype.
    \param  Elements    Number of members in Data.
    \param  Points      Sequence of points to connect with line segments.  Coordinate type set by ctype and RelAbs.

    EMF+ manual 2.3.4.19, Microsoft name: EmfPlusFillPolygon Record, Index 0x0C
*/
int U_PMR_FILLPOLYGON_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *btype, int *ctype, int *RelAbs,
      uint32_t *BrushID, uint32_t *Elements,
      U_PMF_POINTF **Points){
   if(!contents || !btype || !ctype || !RelAbs || !BrushID || !Elements || !Points){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_DRAWLINES))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *btype   = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *ctype   = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *RelAbs  = (lclHeader.Flags & U_PPF_R ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, BrushID,  4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   U_PMF_VARPOINTS_get(contents, lclHeader.Flags, *Elements, Points, blimit);
   return(1);
}

/**
    \brief Get data from a U_PMR_FILLRECTS record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: is index of U_PMF_BRUSH object in EMF+ object table.
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depending on btype.
    \param  Elements    Number of members in Data.
    \param  Rects       Caller must free.  Array of U_PMF_RECTF rectangles to draw.

    EMF+ manual 2.3.4.20, Microsoft name: EmfPlusFillRects Record, Index 0x0A
    
    EMF+ files have been encountered where BrushID must be a color, because it has a value like FFFF0000 but
    the flags are set wrong, so that U_PPF_B is not set.  Detect these by BrushID >63 for btype=0 and correct.
    If the opposite problem occurs it cannot be reliably detected, so it cannot be corrected.

    Rects in record may be either U_PMF_RECT or U_PMF_RECTF, but this function always
    returns U_PMF_RECTF
*/
int U_PMR_FILLRECTS_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *btype, int *ctype,
      uint32_t *BrushID, uint32_t *Elements,
      U_PMF_RECTF **Rects){
   if(!contents || !btype || !ctype || !BrushID || !Elements || !Rects){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_FILLRECTS))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *btype  = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, BrushID,  4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   U_PMF_SERIAL_get(&contents, Elements, 4, 1, U_LE);
   U_PMF_VARRECTS_get(&contents, lclHeader.Flags, *Elements, Rects, blimit);
   /* correct btype, if necessary, for invalid EMF+ input */
   if((*BrushID > 63) & !*btype)*btype=1;
   return(1);
}


/**
    \brief Get data from a U_PMR_FILLREGION record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  RgnID       U_PMF_REGION object in the EMF+ object table (0-63, inclusive)
    \param  btype       Set: BrushID is an U_PFM_ARGB; Clear: is index of U_PMF_BRUSH object in EMF+ object table.
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  BrushID     Color or index of  U_PMF_BRUSH object in the EMF+ object table, depending on btype.

    EMF+ manual 2.3.4.21, Microsoft name: EmfPlusFillRegion Record, Index 0x13
*/
int U_PMR_FILLREGION_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *RgnID, int *btype, int *ctype,
      uint32_t *BrushID){
   if(!contents || !RgnID || !btype || !ctype || !BrushID){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_FILLREGION))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *btype  = (lclHeader.Flags & U_PPF_B ? 1 : 0 );
   *ctype  = (lclHeader.Flags & U_PPF_C ? 1 : 0 );
   *RgnID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   U_PMF_SERIAL_get(&contents, BrushID, 4, 1, (*btype ? U_XE : U_LE)); /* color is not byte swapped, ID integer is */
   return(1);
}

/**
    \brief Get data from a U_PMR_OBJECT record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  ObjID       Index for this object in the EMF+ object table (0-63, inclusive)
    \param  otype       ObjectType enumeration
    \param  ntype       Set: object definition continue bit is set
    \param  TSize       If ntype is set, holds the total number of data bytes split across multiple records.  If ntype is clear, has no meaning.
    \param  Data        Object's data.  Type from otype.

    EMF+ manual 2.3.5.1, Microsoft name: EmfPlusObject Record, Index 0x13
    
    Caller must check Data for possible memory access violations.

    OTHER NOTES:
    All objects are to be stored in the same table and retrieved by index.
    Documentation indicates that this table contains only 64 slots, although the index
       field which references it can code for values 0-127.
    If a new object has the same index as an existing object the old one is deleted and
       the new one goes into its storage slot.
    The continuation bit (U_PPF_N) is documented as indicating that the object is continued into
       the next record.  Examination of emf+ records in emf files produced by PowerPoint 2003
       show that changing the ObjID also serves as a continued record terminator, and that it apparently
       overrides the value for the continue bit.  That is, even though the preceding records said
       that it was continued, the change of ObjID terminates that preceding record without adding
       any more data to it.  In one example the sequential emf+ records were:
       ObjID   type  size  continue
       0       5     65008 Y
       0       5     65008 Y
       0       5     63104 Y
       1       8        24 N
       A DrawImagePoints record followed that referenced ObjID 0. 
    Examination of the records with continue set showed that data in each 
       was preceded by a uint32_t size value equivalent to the size of the 
       data that had been split across multiple records, in this case 
       0x0002F254 = 193108.  It is not clear at present if this size value 
       will also be present at the end of a continued series that terminates 
       by not using the continue bit, rather than changing the ObjID. 
*/
int U_PMR_OBJECT_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint32_t *ObjID, int *otype, int *ntype, uint32_t *TSize,
      const char **Data){
   if(!contents || !ObjID || !otype || !ntype || !Data){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_OBJECT))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *ntype  = (lclHeader.Flags & U_PPF_N ? 1 : 0 );
   *ObjID  = (lclHeader.Flags >> U_FF_SHFT_OID8) & U_FF_MASK_OID8;
   *otype  = (lclHeader.Flags >> U_FF_SHFT_OT) & U_FF_MASK_OT;
   if(*ntype){  U_PMF_SERIAL_get(&contents, TSize, 4, 1,  U_LE); }
   else {       *TSize = 0; }
   U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
   return(1);
}
  
/**
    \brief Get data from a U_PMR_SERIALIZABLEOBJECT record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  GUID        ImageEffects identifier.
    \param  Size        Bytes in Data.
    \param  Data        "Serialized image effects parameter block".  One of the ImageEffects objects.

    EMF+ manual 2.3.5.2, Microsoft name: EmfPlusSerializableObject Record, Index 0x38

    Caller must check Data for possible memory access violations.
*/
int U_PMR_SERIALIZABLEOBJECT_get(const char *contents, U_PMF_CMN_HDR *Header,
      uint8_t *GUID, uint32_t *Size,
      const char **Data){
   if(!contents || !GUID || !Size || !Data){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SERIALIZABLEOBJECT))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   U_PMF_SERIAL_get(&contents, GUID, 1, 16, U_XE);
   U_PMF_SERIAL_get(&contents, Size, 4, 1,  U_LE);
   U_PMF_PTRSAV_SHIFT(Data, &contents, 0);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETANTIALIASMODE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  SMenum      SmoothingMode enumeration
    \param  aatype      Set: anti-aliasing on; Clear: anti-aliasing off

    EMF+ manual 2.3.6.1, Microsoft name: EmfPlusSetAntiAliasMode Record, Index 0x1E
*/
int U_PMR_SETANTIALIASMODE_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *SMenum, int *aatype){
   if(!contents || !SMenum || !aatype){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETANTIALIASMODE))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *aatype = (lclHeader.Flags & U_PPF_AA ? 1 : 0 );
   *SMenum = (lclHeader.Flags >> U_FF_SHFT_AA) & U_FF_MASK_AA;
   return(1);
}

/**
    \brief Get data from a U_PMR_SETCOMPOSITINGMODE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  CMenum      CompositingMode enumeration

    EMF+ manual 2.3.6.2, Microsoft name: EmfPlusSetCompositingMode Record, Index 0x23
*/
int U_PMR_SETCOMPOSITINGMODE_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *CMenum){
   /* memory access safe, only uses the common header */
   if(!contents || !CMenum){ return(0); }
   uint16_t Flags = U_PMF_HEADERFLAGS_get(contents);
   *CMenum  = (Flags >> U_FF_SHFT_CM) & U_FF_MASK_CM;
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETCOMPOSITINGQUALITY record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  CQenum      CompositingQuality enumeration

    EMF+ manual 2.3.6.3, Microsoft name: EmfPlusSetCompositingQuality Record, Index 0x24
*/
int U_PMR_SETCOMPOSITINGQUALITY_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *CQenum){
   /* memory access safe, only uses the common header */
   if(!contents || !CQenum){ return(0); }
   uint16_t Flags = U_PMF_HEADERFLAGS_get(contents);
   *CQenum  = (Flags >> U_FF_SHFT_CQ) & U_FF_MASK_CQ;
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETINTERPOLATIONMODE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  IMenum      InterpolationMode enumeration

    EMF+ manual 2.3.6.4, Microsoft name: EmfPlusSetInterpolationMode Record, Index 0x21
*/
int U_PMR_SETINTERPOLATIONMODE_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *IMenum){
   /* memory access safe, only uses the common header */
   if(!contents || !IMenum){ return(0); }
   uint16_t Flags = U_PMF_HEADERFLAGS_get(contents);
   *IMenum  = (Flags >> U_FF_SHFT_IM) & U_FF_MASK_IM;
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETPIXELOFFSETMODE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  POMenum     PixelOffsetMode enumeration.

    EMF+ manual 2.3.6.5, Microsoft name: EmfPlusSetPixelOffsetMode Record, Index 0x22
*/
int U_PMR_SETPIXELOFFSETMODE_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *POMenum){
   /* memory access safe, only uses the common header */
   if(!contents || !POMenum){ return(0); }
   uint16_t Flags = U_PMF_HEADERFLAGS_get(contents);
   *POMenum  = (Flags >> U_FF_SHFT_PxOffM) & U_FF_MASK_PxOffM;
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETRENDERINGORIGIN record
    \return 1 on success, 0 on error
    \param  contents     Record from which to extract data
    \param  Header       Common header.
    \param  X            X coordinate of rendering origin.
    \param  Y            Y coordinate of rendering origin.

    EMF+ manual 2.3.6.6, Microsoft name: EmfPlusSetRenderingOrigin Record, Index 0x1D
*/
int U_PMR_SETRENDERINGORIGIN_get(const char *contents, U_PMF_CMN_HDR *Header,
      int32_t *X, int32_t *Y){
   if(!contents || !X || !Y){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   if(!U_PMF_CMN_HDR_get(&contents, &lclHeader))return(0);
   if(lclHeader.Size < sizeof(U_PMF_SETRENDERINGORIGIN))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   U_PMF_SERIAL_get(&contents, X, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Y, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETTEXTCONTRAST record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header.
    \param  TGC         Text Gamma correction value (x 1000).

    EMF+ manual 2.3.6.7, Microsoft name: EmfPlusSetTextContrast Record, Index 0x20
*/
int U_PMR_SETTEXTCONTRAST_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *TGC){
   /* memory access safe, only uses the common header */
   if(!contents || !TGC){ return(0); }
   uint16_t Flags = U_PMF_HEADERFLAGS_get(contents);
   *TGC  = (Flags >> U_FF_SHFT_TGC) & U_FF_MASK_TGC;
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETTEXTRENDERINGHINT record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header.
    \param  TRHenum     TextRenderingHint enumeration

    EMF+ manual 2.3.6.8, Microsoft name: EmfPlusSetTextRenderingHint Record, Index 0x1F
*/
int U_PMR_SETTEXTRENDERINGHINT_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *TRHenum){
   /* memory access safe, only uses the common header */
   if(!contents || !TRHenum){ return(0); }
   uint16_t Flags = U_PMF_HEADERFLAGS_get(contents);
   *TRHenum  = (Flags >> U_FF_SHFT_TRH) & U_FF_MASK_TRH;
   U_PMF_CMN_HDR_get(&contents, Header);
   return(1);
}

/**
    \brief Get data from a U_PMR_BEGINCONTAINER record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  UTenum      UnitType enumeration
    \param  DstRect     with SrcRect specifies a transformation
    \param  SrcRect     with DstRect specifies a transformation
    \param  StackID     EMF+ Object Stack Index to use for this graphics container

    EMF+ manual 2.3.7.1, Microsoft name: EmfPlusBeginContainer Record, Index 0x27
*/
int U_PMR_BEGINCONTAINER_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *UTenum,
      U_PMF_RECTF *DstRect, U_PMF_RECTF *SrcRect, uint32_t *StackID){
   if(!contents || !UTenum || !DstRect || !SrcRect || !StackID){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETCLIPREGION))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *UTenum  = (lclHeader.Flags >> U_FF_SHFT_UT) & U_FF_MASK_UT;
   U_PMF_SERIAL_get(&contents, DstRect, 4, 4, U_LE);
   U_PMF_SERIAL_get(&contents, SrcRect, 4, 4, U_LE);
   U_PMF_SERIAL_get(&contents, StackID, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_BEGINCONTAINERNOPARAMS record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  StackID     EMF+ Object Stack Index to use for this graphics container

    EMF+ manual 2.3.7.2, Microsoft name: EmfPlusBeginContainerNoParams Record, Index 0x28
*/
int U_PMR_BEGINCONTAINERNOPARAMS_get(const char *contents, U_PMF_CMN_HDR *Header, uint32_t *StackID){
   return(U_PMR_common_stack_get(contents, Header, StackID));
}

/**
    \brief Get data from a U_PMR_ENDCONTAINER record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  StackID     EMF+ Object Stack Index of this graphics container

    EMF+ manual 2.3.7.3, Microsoft name: EmfPlusEndContainer Record, Index 0x29
*/
int U_PMR_ENDCONTAINER_get(const char *contents, U_PMF_CMN_HDR *Header, uint32_t *StackID){
   return(U_PMR_common_stack_get(contents, Header, StackID));
}

/**
    \brief Get data from a U_PMR_RESTORE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  StackID     State (level) to restore from the EMF+ Graphics Stack. Must have been put on the GS with a U_PMR_SAVE.

    EMF+ manual 2.3.7.4, Microsoft name: EmfPlusRestore Record, Index 0x26
*/
int U_PMR_RESTORE_get(const char *contents, U_PMF_CMN_HDR *Header, uint32_t *StackID){
    return(U_PMR_common_stack_get(contents, Header, StackID));
}

/**
    \brief Get data from a U_PMR_SAVE record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  StackID     State (level) to save.on the EMF+ Graphics Stack

    EMF+ manual 2.3.7.5, Microsoft name: EmfPlusSave Record, Index 0x25
*/
int U_PMR_SAVE_get(const char *contents, U_PMF_CMN_HDR *Header, uint32_t *StackID){
   return(U_PMR_common_stack_get(contents, Header, StackID));
}

/**
    \brief Get data from a U_PMR_SETTSCLIP record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  ctype       Set: int16_t coordinates; Clear: U_FLOAT coordinates
    \param  Elements    Number of members in Data.
    \param  Rects       Caller must free.  Array of rectangles to draw.  Coordinate type set by ctype.

    EMF+ manual 2.3.8.1, Microsoft name: EmfPlusSetTSClip Record, Index 0x3A 
*/
int U_PMR_SETTSCLIP_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *ctype, uint32_t *Elements,
      U_PMF_RECTF **Rects){
   if(!contents || !ctype || !Elements || !Rects){ return(0); }

   const char *blimit = contents;
   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETTSCLIP))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }
   blimit += lclHeader.Size;

   *ctype     = (lclHeader.Flags & U_PPF_K ? 1 : 0 );
   *Elements  = (lclHeader.Flags >> U_FF_SHFT_TSC) & U_FF_MASK_TSC;
   U_PMF_VARRECTS_get(&contents, lclHeader.Flags, *Elements, Rects, blimit);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETTSGRAPHICS record
    \return 1 on success, 0 on error
    \param  contents             Record from which to extract data
    \param  Header               Common header
    \param  vgatype              Set: Palette is VGA basic colors; Clear: Palette is ???
    \param  pptype               Set: Palette is present; Clear: Palette is absent.
    \param  AntiAliasMode        SmoothingMode enumeration
    \param  TextRenderHint       TextRenderingHint enumeration
    \param  CompositingMode      CompositingMode enumeration
    \param  CompositingQuality   CompositingQuality enumeration
    \param  RenderOriginX        Origin X for halftoning and dithering
    \param  RenderOriginY        Origin Y for halftoning and dithering
    \param  TextContrast         Gamma correction, range 0 to 12
    \param  FilterType           FilterType enumeraton
    \param  PixelOffset          PixelOffsetMode enumeration
    \param  WorldToDevice        world to device transform
    \param  Data                 Palette (optional)

    EMF+ manual 2.3.8.2, Microsoft name: EmfPlusSetTSGraphics Record, Index 0x39 

    Caller must check Data for possible memory access violations.
*/
int U_PMR_SETTSGRAPHICS_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *vgatype, int *pptype,
      uint8_t *AntiAliasMode, uint8_t *TextRenderHint, uint8_t  *CompositingMode, uint8_t *CompositingQuality,
      int16_t *RenderOriginX, int16_t *RenderOriginY,  uint16_t *TextContrast,    uint8_t *FilterType,
      uint8_t *PixelOffset,   U_PMF_TRANSFORMMATRIX *WorldToDevice,
      const char **Data){
   if(!contents || !vgatype || !pptype ||
      !AntiAliasMode || !TextRenderHint || !CompositingMode || !CompositingQuality ||
      !RenderOriginX || !RenderOriginY ||  !TextContrast ||    !FilterType ||
      !PixelOffset ||   !WorldToDevice || !Data){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETTSGRAPHICS))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *vgatype     = (lclHeader.Flags & U_PPF_VGA ? 1 : 0 );
   *pptype      = (lclHeader.Flags & U_PPF_PP  ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, AntiAliasMode,      1, 1, U_XE);
   U_PMF_SERIAL_get(&contents, TextRenderHint,     1, 1, U_XE);
   U_PMF_SERIAL_get(&contents, CompositingMode,    1, 1, U_XE);
   U_PMF_SERIAL_get(&contents, CompositingQuality, 1, 1, U_XE);
   U_PMF_SERIAL_get(&contents, RenderOriginX,      2, 1, U_LE);
   U_PMF_SERIAL_get(&contents, RenderOriginY,      2, 1, U_LE);
   U_PMF_SERIAL_get(&contents, TextContrast,       2, 1, U_LE);
   U_PMF_SERIAL_get(&contents, FilterType,         1, 1, U_XE);
   U_PMF_SERIAL_get(&contents, WorldToDevice,      4, 6, U_LE);
   U_PMF_PTRSAV_COND(Data, contents, *pptype);
   return(1);
}

/**
    \brief Get data from a U_PMR_MULTIPLYWORLDTRANSFORM record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  xmtype      Set: Post multiply; Clear: Pre multiply
    \param  Matrix      Transformation matrix

    EMF+ manual 2.3.9.1, Microsoft name: EmfPlusMultiplyWorldTransform Record, Index 0x2C 
*/
int U_PMR_MULTIPLYWORLDTRANSFORM_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *xmtype,
      U_PMF_TRANSFORMMATRIX *Matrix){
   if(!contents || !xmtype || !Matrix){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_MULTIPLYWORLDTRANSFORM))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *xmtype     = (lclHeader.Flags & U_PPF_XM ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, Matrix, 4, 6, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_RESETWORLDTRANSFORM record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header

    EMF+ manual 2.3.9.2, Microsoft name: EmfPlusResetWorldTransform Record, Index 0x2B
*/
int U_PMR_RESETWORLDTRANSFORM_get(const char *contents, U_PMF_CMN_HDR *Header){
   return( U_PMR_common_header_get(contents,Header));
}

/**
    \brief Get data from a U_PMR_ROTATEWORLDTRANSFORM record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  xmtype      Set: Post multiply; Clear: Pre multiply
    \param  Angle       Rotation angle, in degrees

    EMF+ manual 2.3.9.3, Microsoft name: EmfPlusRotateWorldTransform Record, Index 0x2F
*/
int U_PMR_ROTATEWORLDTRANSFORM_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *xmtype,
      U_FLOAT *Angle){
   if(!contents || !xmtype || !Angle){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_ROTATEWORLDTRANSFORM))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *xmtype     = (lclHeader.Flags & U_PPF_XM ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, Angle, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_SCALEWORLDTRANSFORM record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  xmtype      Set: Post multiply; Clear: Pre multiply.
    \param  Sx          X scale factor.
    \param  Sy          Y scale factor.

    EMF+ manual 2.3.9.4, Microsoft name: EmfPlusScaleWorldTransform Record, Index 0x2E
*/
int U_PMR_SCALEWORLDTRANSFORM_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *xmtype,
      U_FLOAT *Sx, U_FLOAT *Sy){
   if(!contents || !xmtype || !Sx || !Sy){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SCALEWORLDTRANSFORM))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *xmtype     = (lclHeader.Flags & U_PPF_XM ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, Sx, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Sy, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETPAGETRANSFORM record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  PUenum      Page Unit, UnitType enumeration
    \param  Scale       Scale factor to convert page space to device space

    EMF+ manual 2.3.9.5, Microsoft name: EmfPlusSetPageTransform Record, Index 0x30
*/
int U_PMR_SETPAGETRANSFORM_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *PUenum,
      U_FLOAT *Scale){
   if(!contents || !PUenum || !Scale){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETPAGETRANSFORM))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *PUenum  = (lclHeader.Flags >> U_FF_SHFT_PU) & U_FF_MASK_PU;
   U_PMF_SERIAL_get(&contents, Scale, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_SETWORLDTRANSFORM record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  Matrix      Transformation matrix

    EMF+ manual 2.3.9.6, Microsoft name: EmfPlusSetWorldTransform Record, Index 0x2A
*/
int U_PMR_SETWORLDTRANSFORM_get(const char *contents, U_PMF_CMN_HDR *Header,
      U_PMF_TRANSFORMMATRIX *Matrix){
   if(!contents || !Matrix){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_SETWORLDTRANSFORM))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   U_PMF_SERIAL_get(&contents, Matrix, 4, 6, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_TRANSLATEWORLDTRANSFORM record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header
    \param  xmtype      Set: Post multiply; Clear: Pre multiply
    \param  Dx          X offset
    \param  Dy          Y offset

    EMF+ manual 2.3.9.7, Microsoft name: EmfPlusTranslateWorldTransform Record, Index 0x2D
*/
int U_PMR_TRANSLATEWORLDTRANSFORM_get(const char *contents, U_PMF_CMN_HDR *Header,
      int *xmtype,
      U_FLOAT *Dx, U_FLOAT *Dy){
   if(!contents || !xmtype || !Dx || !Dy){ return(0); }

   U_PMF_CMN_HDR lclHeader;
   U_PMF_CMN_HDR_get(&contents, &lclHeader);
   if(lclHeader.Size < sizeof(U_PMF_TRANSLATEWORLDTRANSFORM))return(0);
   if(Header){ memcpy(Header,&lclHeader,sizeof(U_PMF_CMN_HDR)); }

   *xmtype     = (lclHeader.Flags & U_PPF_XM ? 1 : 0 );
   U_PMF_SERIAL_get(&contents, Dx, 4, 1, U_LE);
   U_PMF_SERIAL_get(&contents, Dy, 4, 1, U_LE);
   return(1);
}

/**
    \brief Get data from a U_PMR_STROKEFILLPATH record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header  (ignore flags)
    

    EMF+ manual mentioned in 2.1.1.1, not otherwise documented, Microsoft name: EmfPlusStrokeFillPath Record, Index 0x37
    
    "This record closes any open figures in a path, strokes the outline of 
     the path by using the current pen, and fills its interior by using the current brush."
*/
int U_PMR_STROKEFILLPATH_get(const char *contents, U_PMF_CMN_HDR *Header){
   return( U_PMR_common_header_get(contents,Header));
}

/**
    \brief Get data from a U_PMR_MULTIFORMATSTART record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header  (ignore flags)

    EMF+ manual mentioned in 2.1.1.1, reserved, not otherwise documented, Microsoft name: EmfPlusMultiFormatStart Record, Index 0x05 
*/
int U_PMR_MULTIFORMATSTART_get(const char *contents, U_PMF_CMN_HDR *Header){
   return( U_PMR_common_header_get(contents,Header));
}

/**
    \brief Get data from a U_PMR_MULTIFORMATSECTION record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header  (ignore flags)

    EMF+ manual mentioned in 2.1.1.1, reserved, not otherwise documented, Microsoft name: EmfPlusMultiFormatSection Record, Index 0x06 
*/
int U_PMR_MULTIFORMATSECTION_get(const char *contents, U_PMF_CMN_HDR *Header){
   return( U_PMR_common_header_get(contents,Header));
}

/**
    \brief Get data from a U_PMR_MULTIFORMATEND record
    \return 1 on success, 0 on error
    \param  contents    Record from which to extract data
    \param  Header      Common header  (ignore flags)

    EMF+ manual mentioned in 2.1.1.1, reserved, not otherwise documented, Microsoft name: EmfPlusMultiFormatEnd Record, Index 0x06
*/
int U_PMR_MULTIFORMATEND_get(const char *contents, U_PMF_CMN_HDR *Header){
   return( U_PMR_common_header_get(contents,Header));
}


#ifdef __cplusplus
}
#endif