diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:24:48 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:24:48 +0000 |
commit | cca66b9ec4e494c1d919bff0f71a820d8afab1fa (patch) | |
tree | 146f39ded1c938019e1ed42d30923c2ac9e86789 /src/3rdparty/libuemf/uwmf_endian.c | |
parent | Initial commit. (diff) | |
download | inkscape-upstream.tar.xz inkscape-upstream.zip |
Adding upstream version 1.2.2.upstream/1.2.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | src/3rdparty/libuemf/uwmf_endian.c | 1774 |
1 files changed, 1774 insertions, 0 deletions
diff --git a/src/3rdparty/libuemf/uwmf_endian.c b/src/3rdparty/libuemf/uwmf_endian.c new file mode 100644 index 0000000..7a047c2 --- /dev/null +++ b/src/3rdparty/libuemf/uwmf_endian.c @@ -0,0 +1,1774 @@ +/** + @file uwmf_endian.c + + @brief Functions for converting WMF records between Big Endian and Little Endian byte orders. +*/ + +/* +File: uwmf_endian.c +Version: 0.1.5 +Date: 28-MAY-2015 +Author: David Mathog, Biology Division, Caltech +email: mathog@caltech.edu +Copyright: 2015 David Mathog and California Institute of Technology (Caltech) +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdlib.h> +#include <stdio.h> +#include <stddef.h> /* for offsetof() */ +#include <string.h> +#include "uwmf.h" +#include "uwmf_endian.h" + +// hide almost everything in this file from Doxygen +//! \cond +/* 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); +void bitmapinfo_swap(char *Bmi); + +/* ********************************************************************************************** + These functions Swap standard objects used in the WMR records. + The low level ones do not append EOL. +*********************************************************************************************** */ + +/** + \brief Swap U_BITMAP16 object + \param b U_BITMAP16 object +*/ +void bitmap16_swap( + char *b + ){ + U_swap2(b,4); /* Type, Width, Height, WidthBytes */ + /* Planes and BitsPixel are bytes, so no swap needed */ + /* Bits[] pixel data should already be in order */ +} + +/** + \brief Swap a U_BRUSH object. + \param b U_BRUSH object. + style bColor bHatch + U_BS_SOLID ColorRef Object Not used (bytes present???) + U_BS_NULL ignored ignored (bytes present???). + U_BS_PATTERN ignored Bitmap16 object holding patern + U_BS_DIBPATTERNPT ColorUsage Enum DIB object + U_BS_HATCHED ColorRef Object HatchStyle Enumeration +*/ +void brush_swap( + char *b, + int torev + ){ + int Style; + if(torev){ Style = *(uint16_t *)(b + offsetof(U_BRUSH,Style)); } + U_swap2(b + offsetof(U_BRUSH,Style),1); + if(!torev){ Style = *(uint16_t *)(b + offsetof(U_BRUSH,Style)); } + /* Color is already in the right order */ + switch(Style){ + case U_BS_SOLID: + /* no/ignored data field */ + break; + case U_BS_NULL: + /* no/ignored data field */ + break; + case U_BS_PATTERN: + bitmap16_swap(b + offsetof(U_BRUSH,Data)); + break; + case U_BS_DIBPATTERNPT: + bitmapinfo_swap(b + offsetof(U_BRUSH,Data)); + break; + case U_BS_HATCHED: + /* no/ignored data field */ + break; + } +} + +/** + \brief Swap a U_FONT object from pointer. + \param lf U_FONT object +*/ +void font_swap( + char *f + ){ + U_swap2(f + offsetof(U_FONT,Height),5); /*Height, Width, Escapement, Orientation, Weight */ + /* Other fields are single bytes */ +} + +/** + \brief Swap a pointer to a U_PALETTE object. + \param lp Pointer to a U_PALETTE object. +*/ +void palette_swap( + char *p + ){ + U_swap2(p + offsetof(U_PALETTE,Start),2); /* Start, NumEntries*/ + /* PalEntries[1] is byte ordered, so no need to swap */ +} + +/** + \brief Swap a U_PEN object. + \param p U_PEN object +*/ +void pen_swap( + char *p + ){ + U_swap2(p + offsetof(U_PEN,Style),3); /* Style,Widthw[0],Widthw[1] */ + /* Color already in order */ +} + +/* there are no + void rect16_ltrb_swap() + void rect16_brtl_swap() +because rectangles are swapped using U_swap2 as an array of 4 int16 values. +*/ + + +/** + \brief Swap U_REGION object + \param rect U_REGION object + \param torev + PARTIAL IMPLEMENTATION +*/ +void region_swap( + char *reg, + int torev + ){ + int Size; + if(torev){ Size = *(int16_t *)(reg + offsetof(U_REGION,Size)); } + U_swap2(reg,10); /* ignore1 through sRrect*/ + if(!torev){ Size = *(int16_t *)(reg + offsetof(U_REGION,Size)); } + U_swap2(reg + U_SIZE_REGION, (Size - U_SIZE_REGION)/2); /* aScans */ +} + + +/** + \brief Swap U_BITMAPCOREHEADER object + \param ch U_BITMAPCOREHEADER object +*/ +void bitmapcoreheader_swap( + char *ch + ){ + U_swap4(ch + offsetof(U_BITMAPCOREHEADER,Size_4), 1); /* Size_4, may not be aligned */ + U_swap2(ch + offsetof(U_BITMAPCOREHEADER,Width),4); /* Width, Height, Planes, BitCount, */ +} + +/** LogBrushW Object WMF PDF 2.2.2.10 + \brief Swap a U_WLOGBRUSH object. + \param lb U_WLOGBRUSH object. + + style Color Hatch + U_BS_SOLID ColorRef Object Not used (bytes present???) + U_BS_NULL ignored ignored (bytes present???). + U_BS_PATTERN ignored not used (Action is not strictly defined) + U_BS_DIBPATTERN ignored not used (Action is not strictly defined) + U_BS_DIBPATTERNPT ignored not used (Action is not strictly defined) + U_BS_HATCHED ColorRef Object HatchStyle Enumeration +*/ +void wlogbrush_swap( + char *lb + ){ + U_swap2(lb + offsetof(U_WLOGBRUSH,Style),1); + /* Color is already in order */ + U_swap2(lb + offsetof(U_WLOGBRUSH,Hatch),1); +} + +/** + \brief Swap U_POLYPOLY object from pointer + \param pp PU_POLYPOLY object +*/ +void polypolygon_swap( + char *pp, + int torev + ){ + int i,totPoints; + uint16_t nPolys; + uint16_t *aPolyCounts; + if(torev){ nPolys = *(uint16_t *)(pp + offsetof(U_POLYPOLYGON, nPolys)); } + U_swap2(pp + offsetof(U_POLYPOLYGON, nPolys),1); + if(!torev){ nPolys = *(uint16_t *)(pp + offsetof(U_POLYPOLYGON, nPolys)); } + aPolyCounts = (uint16_t *)(pp + offsetof(U_POLYPOLYGON, aPolyCounts)); + if(torev){ + for(totPoints=0,i=0;i<nPolys; i++){ totPoints += aPolyCounts[i]; } + } + U_swap2(aPolyCounts,nPolys); + if(!torev){ + for(totPoints=0,i=0;i<nPolys; i++){ totPoints += aPolyCounts[i]; } + } + U_swap2(&(aPolyCounts[nPolys]),2*totPoints); /* 2 coords/ point */ +} + +/** + \brief Swap U_SCAN object + \param pp U_SCAN object +*/ +void scan_swap( + char *sc, + int torev + ){ + int count; + if(torev){ count = *(uint16_t *)sc; } + U_swap2(sc,3); /*count, top, bottom */ + if(!torev){ count = *(uint16_t *)sc; } + U_swap2(sc + offsetof(U_SCAN,ScanLines),count); +} + +/** + \brief Swap a summary of a DIB header + A DIB header in an WMF may be either a BitmapCoreHeader or BitmapInfoHeader. + \param dh void pointer to DIB header +*/ +void dibheader_swap( + char *dh, + int torev + ){ + int Size; + memcpy(&Size, dh, 4); /* may not be aligned */ + if(!torev)U_swap4(&Size,1); + if(Size == 0xC){ + bitmapcoreheader_swap(dh); + } + else { + bitmapinfo_swap(dh); + } +} + +/** + \brief Swap WMF header object + \param head uint8_t pointer to header + \returns size of entire header structure + + If the header is preceded by a placeable struture, Swap that as well. +*/ +int wmfheader_swap( + char *contents, + int torev + ){ + uint32_t Key,Size16w; + int size=0; + Key=*(uint32_t *)(contents + offsetof(U_WMRPLACEABLE,Key)); + if(!torev)U_swap4(&Key,1); + if(Key == 0x9AC6CDD7){ + U_swap4(contents + offsetof(U_WMRPLACEABLE,Key ),1); + U_swap2(contents + offsetof(U_WMRPLACEABLE,HWmf ),1); + U_swap2(contents + offsetof(U_WMRPLACEABLE,Dst ),4); + U_swap2(contents + offsetof(U_WMRPLACEABLE,Inch ),1); + U_swap4(contents + offsetof(U_WMRPLACEABLE,Reserved),1); + U_swap2(contents + offsetof(U_WMRPLACEABLE,Checksum),1); + contents += U_SIZE_WMRPLACEABLE; + size += U_SIZE_WMRPLACEABLE; + } + if(torev){ Size16w = *(uint16_t *)(contents + offsetof(U_WMRHEADER,Size16w)); } + U_swap2(contents + offsetof(U_WMRHEADER,Size16w),2);/* Size16w, Version */ + if(!torev){ Size16w = *(uint16_t *)(contents + offsetof(U_WMRHEADER,Size16w)); } + U_swap4(contents + offsetof(U_WMRHEADER,Sizew ),1);/* Sizew */ + U_swap2(contents + offsetof(U_WMRHEADER,nObjects),1);/* nObjects */ + U_swap4(contents + offsetof(U_WMRHEADER,maxSize ),1);/* maxSize */ + U_swap2(contents + offsetof(U_WMRHEADER,nMembers),1);/* nMembers */ + size += 2*Size16w; + return(size); +} + + + +/* ********************************************************************************************** +These functions contain shared code used by various U_WMR*_Swap functions. These should NEVER be called +by end user code and to further that end prototypes are NOT provided and they are hidden from Doxygen. +*********************************************************************************************** */ + +/* Size16 EVERY record type should call this, directly or indirectly*/ +void U_WMRCORE_SIZE16_swap(char *record, int torev){ + UNUSED_PARAMETER(torev); + U_swap4(record, 1); /* Size16_4 is at offset 0 in U_METARECORD */ +} + + +/* Size16, move to data, Single 32bit followed by array of N16 U_POINT16 */ +void U_WMRCORE_U32_N16_swap(char *record, int N16, int torev){ + int off=U_SIZE_METARECORD; + U_WMRCORE_SIZE16_swap(record, torev); + U_swap4(record + off, 1); off+=4; + U_swap2(record + off, N16); +} + +/* Single 16bit nPoints followed by array of nPoints U_POINT16 */ +void U_WMRCORE_U16_N16_swap(char *record, int torev){ + int nPoints; + U_WMRCORE_SIZE16_swap(record, torev); + if(torev){ nPoints = *(uint16_t *)(record + offsetof(U_WMRPOLYGON,nPoints)); } + U_swap2(record + offsetof(U_WMRPOLYGON,nPoints), 1); + if(!torev){ nPoints = *(uint16_t *)(record + offsetof(U_WMRPOLYGON,nPoints)); } + U_swap2(record + offsetof(U_WMRPOLYGON,aPoints), 2*nPoints); +} + +/* all records that specify palette objects */ +void U_WMRCORE_PALETTE_swap(char *record, int torev){ + UNUSED_PARAMETER(torev); + U_WMRCORE_SIZE16_swap(record, torev); + palette_swap(record + offsetof(U_WMRANIMATEPALETTE,Palette)); +} + +/* all records that have N int16 values, unconditionally swapped */ +void U_WMRCORE_N16_swap(char *record, int N16, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); + U_swap2(record+U_SIZE_METARECORD, N16); +} + + +/* like floodfill */ +void U_WMRCORE_U16_CR_2U16_swap(char *record, int torev){ + int off = U_SIZE_METARECORD; + U_WMRCORE_SIZE16_swap(record, torev); + U_swap2(record+off, 1); off += 2 + sizeof(U_COLORREF); + U_swap2(record+off, 2); +} + +/* ********************************************************************************************** +These are the core WMR functions, each creates a particular type of record. +All return these records via a char* pointer, which is NULL if the call failed. +They are listed in order by the corresponding U_EMR_* index number. +*********************************************************************************************** */ + +/** + \brief Swap a pointer to a U_WMR_whatever record which has not been implemented. + \param name name of this type of record + \param contents pointer to a buffer holding all EMR records + \param recnum number of this record in contents + \param off offset to this record in contents +*/ +void U_WMRNOTIMPLEMENTED_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); +} + +void U_WMREOF_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); +} + +void U_WMRSETBKCOLOR_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); +} + +void U_WMRSETBKMODE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSETMAPMODE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSETROP2_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSETRELABS_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); +} + +void U_WMRSETPOLYFILLMODE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSETSTRETCHBLTMODE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSETTEXTCHAREXTRA_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSETTEXTCOLOR_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); +} + +void U_WMRSETTEXTJUSTIFICATION_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRSETWINDOWORG_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRSETWINDOWEXT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRSETVIEWPORTORG_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRSETVIEWPORTEXT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMROFFSETWINDOWORG_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRSCALEWINDOWEXT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,4,torev); +} + +void U_WMROFFSETVIEWPORTORG_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRSCALEVIEWPORTEXT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,4,torev); +} + +void U_WMRLINETO_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRMOVETO_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMREXCLUDECLIPRECT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,4,torev); +} + +void U_WMRINTERSECTCLIPRECT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,4,torev); +} + +void U_WMRARC_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record, 8, torev); +} + +void U_WMRELLIPSE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,4,torev); +} + +void U_WMRFLOODFILL_swap(char *record, int torev){ + U_WMRCORE_U16_CR_2U16_swap(record, torev); +} + +void U_WMRPIE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record, 8, torev); +} + +void U_WMRRECTANGLE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,4,torev); +} + +void U_WMRROUNDRECT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,6,torev); +} + +void U_WMRPATBLT_swap(char *record, int torev){ + U_WMRCORE_U32_N16_swap(record,4,torev); +} + +void U_WMRSAVEDC_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); +} + +void U_WMRSETPIXEL_swap(char *record, int torev){ + int off = U_SIZE_METARECORD + sizeof(U_COLORREF); + U_WMRCORE_SIZE16_swap(record, torev); + U_swap2(record+off, 2); +} + +void U_WMROFFSETCLIPRGN_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRTEXTOUT_swap(char *record, int torev){ + int L2; + if(torev){ L2 = *(int16_t *)(record + U_SIZE_METARECORD); } /* Length field */ + U_WMRCORE_N16_swap(record,1,torev); /* Length */ + if(!torev){ L2 = *(int16_t *)(record + U_SIZE_METARECORD); } /* Length field */ + /* string is in bytes, do not swap that */ + U_swap2(record + U_SIZE_WMRTEXTOUT + L2, 2); /* y,x */ +} + +void U_WMRBITBLT_swap(char *record, int torev){ + uint32_t Size16; + uint8_t xb; + memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4); + if(!torev)U_swap4(&Size16,1); + xb = *(uint8_t *)(record + offsetof(U_METARECORD,xb)); + if(U_TEST_NOPX2(Size16,xb)){ /* no bitmap */ + U_WMRCORE_U32_N16_swap(record,7,torev); + } + else { /* yes bitmap */ + U_WMRCORE_U32_N16_swap(record,6,torev); + bitmap16_swap(record + offsetof(U_WMRBITBLT_PX,bitmap)); + } +} + +void U_WMRSTRETCHBLT_swap(char *record, int torev){ + uint32_t Size16; + uint8_t xb; + memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4); + if(!torev)U_swap4(&Size16,1); + xb = *(uint8_t *)(record + offsetof(U_METARECORD,xb)); + if(U_TEST_NOPX2(Size16,xb)){ /* no bitmap */ + U_WMRCORE_U32_N16_swap(record,9,torev); + } + else { /* yes bitmap */ + U_WMRCORE_U32_N16_swap(record,8,torev); + bitmap16_swap(record + offsetof(U_WMRSTRETCHBLT_PX,bitmap)); + } +} + +void U_WMRPOLYGON_swap(char *record, int torev){ + U_WMRCORE_U16_N16_swap(record, torev); +} + +void U_WMRPOLYLINE_swap(char *record, int torev){ + U_WMRCORE_U16_N16_swap(record, torev); +} + +void U_WMRESCAPE_swap(char *record, int torev){ + uint16_t eFunc; + + if(torev){ eFunc = *(uint16_t *)(record + offsetof(U_WMRESCAPE,eFunc)); } + U_WMRCORE_N16_swap(record,2,torev); + if(!torev){ eFunc = *(uint16_t *)(record + offsetof(U_WMRESCAPE,eFunc)); } + /* Handle data swapping for three types only, anything else end user code must handle */ + if((eFunc == U_MFE_SETLINECAP) || (eFunc == U_MFE_SETLINEJOIN) || (eFunc == U_MFE_SETMITERLIMIT)){ + U_swap4(record + offsetof(U_WMRESCAPE, Data),1); + } +} + +void U_WMRRESTOREDC_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); +} + +void U_WMRFILLREGION_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,2,torev); +} + +void U_WMRFRAMEREGION_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,4,torev); +} + +void U_WMRINVERTREGION_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRPAINTREGION_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSELECTCLIPREGION_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSELECTOBJECT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRSETTEXTALIGN_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRDRAWTEXT_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCHORD_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record, 8, torev); +} + +void U_WMRSETMAPPERFLAGS_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMREXTTEXTOUT_swap(char *record, int torev){ + int off,Length,Len2,Opts; + U_swap4(record + offsetof(U_WMREXTTEXTOUT,Size16_4),1); + if(torev){ + Length = *(int16_t *)( record + offsetof(U_WMREXTTEXTOUT,Length)); + Opts = *(uint16_t *)(record + offsetof(U_WMREXTTEXTOUT,Opts)); + } + U_swap2(record + offsetof(U_WMREXTTEXTOUT,y), 4); /* y,x,Length,Opts*/ + if(!torev){ + Length = *(int16_t *)( record + offsetof(U_WMREXTTEXTOUT,Length)); + Opts = *(uint16_t *)(record + offsetof(U_WMREXTTEXTOUT,Opts)); + } + off = U_SIZE_WMREXTTEXTOUT; + if(Opts & (U_ETO_OPAQUE | U_ETO_CLIPPED)){ + U_swap2(record + off,4); off += 8; + } + Len2 = (Length & 1 ? Length + 1 : Length); + off += Len2; /* no need to swap string, it is a byte array */ + U_swap2(record+off,Length); /* swap the dx array */ +} + +void U_WMRSETDIBTODEV_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record, 9, torev); + dibheader_swap(record + offsetof(U_WMRSETDIBTODEV,dib), torev); +} + +void U_WMRSELECTPALETTE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRREALIZEPALETTE_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); +} + +void U_WMRANIMATEPALETTE_swap(char *record, int torev){ + U_WMRCORE_PALETTE_swap(record, torev); +} + +void U_WMRSETPALENTRIES_swap(char *record, int torev){ + U_WMRCORE_PALETTE_swap(record, torev); +} + +void U_WMRPOLYPOLYGON_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); + polypolygon_swap(record + offsetof(U_WMRPOLYPOLYGON,PPolygon), torev); +} + +void U_WMRRESIZEPALETTE_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMR3A_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR3B_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR3C_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR3D_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR3E_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR3F_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRDIBBITBLT_swap(char *record, int torev){ + uint32_t Size16; + uint8_t xb; + memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4); + if(!torev)U_swap4(&Size16,1); + xb = *(uint8_t *)(record + offsetof(U_METARECORD,xb)); + if(U_TEST_NOPX2(Size16,xb)){ /* no bitmap */ + U_WMRCORE_U32_N16_swap(record,7,torev); + } + else { /* yes bitmap */ + U_WMRCORE_U32_N16_swap(record,6,torev); + dibheader_swap(record + offsetof(U_WMRDIBBITBLT_PX,dib), torev); + } +} + +void U_WMRDIBSTRETCHBLT_swap(char *record, int torev){ + uint32_t Size16; + uint8_t xb; + memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4); + if(!torev)U_swap4(&Size16,1); + xb = *(uint8_t *)(record + offsetof(U_METARECORD,xb)); + if(U_TEST_NOPX2(Size16,xb)){ /* no bitmap */ + U_WMRCORE_U32_N16_swap(record,9,torev); + } + else { /* yes bitmap */ + U_WMRCORE_U32_N16_swap(record,8,torev); + dibheader_swap(record + offsetof(U_WMRDIBSTRETCHBLT_PX,dib), torev); + } +} + +void U_WMRDIBCREATEPATTERNBRUSH_swap(char *record, int torev){ + int Style; + if(torev){ Style = *(uint16_t *)(record + offsetof(U_WMRDIBCREATEPATTERNBRUSH,Style)); } + U_WMRCORE_N16_swap(record,2,torev); /* Style and cUsage */ + if(!torev){ Style = *(uint16_t *)(record + offsetof(U_WMRDIBCREATEPATTERNBRUSH,Style)); } + if(Style == U_BS_PATTERN){ + bitmap16_swap(record + offsetof(U_WMRDIBCREATEPATTERNBRUSH,Src)); + } + else { + dibheader_swap(record + offsetof(U_WMRDIBCREATEPATTERNBRUSH,Src), torev); + } +} + +void U_WMRSTRETCHDIB_swap(char *record, int torev){ + UNUSED_PARAMETER(torev); + U_WMRCORE_U32_N16_swap(record,9,torev); + dibheader_swap(record + offsetof(U_WMRSTRETCHDIB,dib), torev); +} + +void U_WMR44_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR45_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR46_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR47_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMREXTFLOODFILL_swap(char *record, int torev){ + U_WMRCORE_U16_CR_2U16_swap(record, torev); +} + +void U_WMR49_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR4A_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR4B_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR4C_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR4D_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR4E_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR4F_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR50_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR51_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR52_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR53_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR54_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR55_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR56_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR57_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR58_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR59_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR5A_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR5B_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR5C_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR5D_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR5E_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR5F_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR60_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR61_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR62_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR63_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR64_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR65_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR66_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR67_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR68_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR69_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR6A_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR6B_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR6C_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR6D_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR6E_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR6F_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR70_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR71_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR72_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR73_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR74_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR75_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR76_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR77_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR78_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR79_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR7A_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR7B_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR7C_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR7D_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR7E_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR7F_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR80_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR81_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR82_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR83_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR84_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR85_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR86_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR87_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR88_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR89_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR8A_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR8B_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR8C_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR8D_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR8E_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR8F_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR90_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR91_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR92_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR93_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR94_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR95_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR96_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR97_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR98_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR99_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR9A_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR9B_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR9C_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR9D_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR9E_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMR9F_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA0_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA1_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA2_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA3_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA4_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA5_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA6_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA7_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA8_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRA9_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRAA_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRAB_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRAC_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRAD_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRAE_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRAF_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB0_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB1_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB2_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB3_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB4_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB5_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB6_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB7_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB8_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRB9_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRBA_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRBB_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRBC_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRBD_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRBE_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRBF_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC0_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC1_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC2_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC3_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC4_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC5_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC6_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC7_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC8_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRC9_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCA_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCB_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCC_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCD_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCE_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCF_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD0_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD1_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD2_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD3_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD4_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD5_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD6_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD7_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD8_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRD9_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRDA_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRDB_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRDC_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRDD_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRDE_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRDF_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE0_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE1_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE2_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE3_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE4_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE5_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE6_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE7_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE8_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRE9_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMREA_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMREB_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMREC_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRED_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMREE_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMREF_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRDELETEOBJECT_swap(char *record, int torev){ + U_WMRCORE_N16_swap(record,1,torev); +} + +void U_WMRF1_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRF2_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRF3_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRF4_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRF5_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRF6_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCREATEPALETTE_swap(char *record, int torev){ + U_WMRCORE_PALETTE_swap(record, torev); +} + +void U_WMRF8_swap(char *record, int torev){ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCREATEPATTERNBRUSH_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); + bitmap16_swap(record + U_SIZE_METARECORD); + /* pattern array byte order already correct? */ +} + +void U_WMRCREATEPENINDIRECT_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); + pen_swap(record + offsetof(U_WMRCREATEPENINDIRECT,pen)); +} + +void U_WMRCREATEFONTINDIRECT_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); + font_swap(record + offsetof(U_WMRCREATEFONTINDIRECT,font)); +} + +void U_WMRCREATEBRUSHINDIRECT_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); + wlogbrush_swap(record + offsetof(U_WMRCREATEBRUSHINDIRECT,brush)); +} + +void U_WMRCREATEBITMAPINDIRECT_swap(char *record, int torev){ /* in Wine, not in WMF PDF */ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCREATEBITMAP_swap(char *record, int torev){ /* in Wine, not in WMF PDF */ + U_WMRNOTIMPLEMENTED_swap(record, torev); +} + +void U_WMRCREATEREGION_swap(char *record, int torev){ + U_WMRCORE_SIZE16_swap(record, torev); + region_swap(record + offsetof(U_WMRCREATEREGION,region), torev); +} +//! \endcond + +/** + \brief Convert an entire WMF in memory from Big Endian to Little Endian (or vice versa). + \return 0 on failure, 1 on success + \param contents pointer to the buffer holding the entire EMF in memory + \param length number of bytes in the buffer + \param torev 1 for native to reversed, 0 for reversed to native + \param onerec 1 if this is operating on a single record instead of an entire file + + Normally this would be called immediately before writing the data to a file + or immediately after reading the data from a file. +*/ +int U_wmf_endian(char *contents, size_t length, int torev, int onerec){ + size_t off=0; + uint32_t OK, Size16; + uint8_t iType; + char *record; + int recnum; + int offset=0; + + record = contents; + if(!onerec){ + off = wmfheader_swap(record,torev); fflush(stdout); /* WMF header is not a normal record, handle it separately */ + record += off; + offset = off; + } + OK = 1; + recnum = 1; /* used when debugging */ + + while(OK){ + if(record > contents + length){ return(0); } // this is most likely a corrupt WMF + + memcpy(&Size16, record + offsetof(U_METARECORD,Size16_4), 4); /* This may not be aligned */ + if(!torev){ U_swap4(&Size16,1); } + iType = *(uint8_t *)(record + offsetof(U_METARECORD,iType)); + +//printf("DEBUG U_wmf_endian before switch record:%d offset:%d type:%d name:%s Size16:%d\n",recnum,offset,iType,U_wmr_names(iType),Size16);fflush(stdout); + switch (iType) + { + case U_WMR_EOF: U_WMREOF_swap(record, torev); OK=0; break; + case U_WMR_SETBKCOLOR: U_WMRSETBKCOLOR_swap(record, torev); break; + case U_WMR_SETBKMODE: U_WMRSETBKMODE_swap(record, torev); break; + case U_WMR_SETMAPMODE: U_WMRSETMAPMODE_swap(record, torev); break; + case U_WMR_SETROP2: U_WMRSETROP2_swap(record, torev); break; + case U_WMR_SETRELABS: U_WMRSETRELABS_swap(record, torev); break; + case U_WMR_SETPOLYFILLMODE: U_WMRSETPOLYFILLMODE_swap(record, torev); break; + case U_WMR_SETSTRETCHBLTMODE: U_WMRSETSTRETCHBLTMODE_swap(record, torev); break; + case U_WMR_SETTEXTCHAREXTRA: U_WMRSETTEXTCHAREXTRA_swap(record, torev); break; + case U_WMR_SETTEXTCOLOR: U_WMRSETTEXTCOLOR_swap(record, torev); break; + case U_WMR_SETTEXTJUSTIFICATION: U_WMRSETTEXTJUSTIFICATION_swap(record, torev); break; + case U_WMR_SETWINDOWORG: U_WMRSETWINDOWORG_swap(record, torev); break; + case U_WMR_SETWINDOWEXT: U_WMRSETWINDOWEXT_swap(record, torev); break; + case U_WMR_SETVIEWPORTORG: U_WMRSETVIEWPORTORG_swap(record, torev); break; + case U_WMR_SETVIEWPORTEXT: U_WMRSETVIEWPORTEXT_swap(record, torev); break; + case U_WMR_OFFSETWINDOWORG: U_WMROFFSETWINDOWORG_swap(record, torev); break; + case U_WMR_SCALEWINDOWEXT: U_WMRSCALEWINDOWEXT_swap(record, torev); break; + case U_WMR_OFFSETVIEWPORTORG: U_WMROFFSETVIEWPORTORG_swap(record, torev); break; + case U_WMR_SCALEVIEWPORTEXT: U_WMRSCALEVIEWPORTEXT_swap(record, torev); break; + case U_WMR_LINETO: U_WMRLINETO_swap(record, torev); break; + case U_WMR_MOVETO: U_WMRMOVETO_swap(record, torev); break; + case U_WMR_EXCLUDECLIPRECT: U_WMREXCLUDECLIPRECT_swap(record, torev); break; + case U_WMR_INTERSECTCLIPRECT: U_WMRINTERSECTCLIPRECT_swap(record, torev); break; + case U_WMR_ARC: U_WMRARC_swap(record, torev); break; + case U_WMR_ELLIPSE: U_WMRELLIPSE_swap(record, torev); break; + case U_WMR_FLOODFILL: U_WMRFLOODFILL_swap(record, torev); break; + case U_WMR_PIE: U_WMRPIE_swap(record, torev); break; + case U_WMR_RECTANGLE: U_WMRRECTANGLE_swap(record, torev); break; + case U_WMR_ROUNDRECT: U_WMRROUNDRECT_swap(record, torev); break; + case U_WMR_PATBLT: U_WMRPATBLT_swap(record, torev); break; + case U_WMR_SAVEDC: U_WMRSAVEDC_swap(record, torev); break; + case U_WMR_SETPIXEL: U_WMRSETPIXEL_swap(record, torev); break; + case U_WMR_OFFSETCLIPRGN: U_WMROFFSETCLIPRGN_swap(record, torev); break; + case U_WMR_TEXTOUT: U_WMRTEXTOUT_swap(record, torev); break; + case U_WMR_BITBLT: U_WMRBITBLT_swap(record, torev); break; + case U_WMR_STRETCHBLT: U_WMRSTRETCHBLT_swap(record, torev); break; + case U_WMR_POLYGON: U_WMRPOLYGON_swap(record, torev); break; + case U_WMR_POLYLINE: U_WMRPOLYLINE_swap(record, torev); break; + case U_WMR_ESCAPE: U_WMRESCAPE_swap(record, torev); break; + case U_WMR_RESTOREDC: U_WMRRESTOREDC_swap(record, torev); break; + case U_WMR_FILLREGION: U_WMRFILLREGION_swap(record, torev); break; + case U_WMR_FRAMEREGION: U_WMRFRAMEREGION_swap(record, torev); break; + case U_WMR_INVERTREGION: U_WMRINVERTREGION_swap(record, torev); break; + case U_WMR_PAINTREGION: U_WMRPAINTREGION_swap(record, torev); break; + case U_WMR_SELECTCLIPREGION: U_WMRSELECTCLIPREGION_swap(record, torev); break; + case U_WMR_SELECTOBJECT: U_WMRSELECTOBJECT_swap(record, torev); break; + case U_WMR_SETTEXTALIGN: U_WMRSETTEXTALIGN_swap(record, torev); break; + case U_WMR_DRAWTEXT: U_WMRDRAWTEXT_swap(record, torev); break; + case U_WMR_CHORD: U_WMRCHORD_swap(record, torev); break; + case U_WMR_SETMAPPERFLAGS: U_WMRSETMAPPERFLAGS_swap(record, torev); break; + case U_WMR_EXTTEXTOUT: U_WMREXTTEXTOUT_swap(record, torev); break; + case U_WMR_SETDIBTODEV: U_WMRSETDIBTODEV_swap(record, torev); break; + case U_WMR_SELECTPALETTE: U_WMRSELECTPALETTE_swap(record, torev); break; + case U_WMR_REALIZEPALETTE: U_WMRREALIZEPALETTE_swap(record, torev); break; + case U_WMR_ANIMATEPALETTE: U_WMRANIMATEPALETTE_swap(record, torev); break; + case U_WMR_SETPALENTRIES: U_WMRSETPALENTRIES_swap(record, torev); break; + case U_WMR_POLYPOLYGON: U_WMRPOLYPOLYGON_swap(record, torev); break; + case U_WMR_RESIZEPALETTE: U_WMRRESIZEPALETTE_swap(record, torev); break; + case U_WMR_3A: U_WMR3A_swap(record, torev); break; + case U_WMR_3B: U_WMR3B_swap(record, torev); break; + case U_WMR_3C: U_WMR3C_swap(record, torev); break; + case U_WMR_3D: U_WMR3D_swap(record, torev); break; + case U_WMR_3E: U_WMR3E_swap(record, torev); break; + case U_WMR_3F: U_WMR3F_swap(record, torev); break; + case U_WMR_DIBBITBLT: U_WMRDIBBITBLT_swap(record, torev); break; + case U_WMR_DIBSTRETCHBLT: U_WMRDIBSTRETCHBLT_swap(record, torev); break; + case U_WMR_DIBCREATEPATTERNBRUSH: U_WMRDIBCREATEPATTERNBRUSH_swap(record, torev); break; + case U_WMR_STRETCHDIB: U_WMRSTRETCHDIB_swap(record, torev); break; + case U_WMR_44: U_WMR44_swap(record, torev); break; + case U_WMR_45: U_WMR45_swap(record, torev); break; + case U_WMR_46: U_WMR46_swap(record, torev); break; + case U_WMR_47: U_WMR47_swap(record, torev); break; + case U_WMR_EXTFLOODFILL: U_WMREXTFLOODFILL_swap(record, torev); break; + case U_WMR_49: U_WMR49_swap(record, torev); break; + case U_WMR_4A: U_WMR4A_swap(record, torev); break; + case U_WMR_4B: U_WMR4B_swap(record, torev); break; + case U_WMR_4C: U_WMR4C_swap(record, torev); break; + case U_WMR_4D: U_WMR4D_swap(record, torev); break; + case U_WMR_4E: U_WMR4E_swap(record, torev); break; + case U_WMR_4F: U_WMR4F_swap(record, torev); break; + case U_WMR_50: U_WMR50_swap(record, torev); break; + case U_WMR_51: U_WMR51_swap(record, torev); break; + case U_WMR_52: U_WMR52_swap(record, torev); break; + case U_WMR_53: U_WMR53_swap(record, torev); break; + case U_WMR_54: U_WMR54_swap(record, torev); break; + case U_WMR_55: U_WMR55_swap(record, torev); break; + case U_WMR_56: U_WMR56_swap(record, torev); break; + case U_WMR_57: U_WMR57_swap(record, torev); break; + case U_WMR_58: U_WMR58_swap(record, torev); break; + case U_WMR_59: U_WMR59_swap(record, torev); break; + case U_WMR_5A: U_WMR5A_swap(record, torev); break; + case U_WMR_5B: U_WMR5B_swap(record, torev); break; + case U_WMR_5C: U_WMR5C_swap(record, torev); break; + case U_WMR_5D: U_WMR5D_swap(record, torev); break; + case U_WMR_5E: U_WMR5E_swap(record, torev); break; + case U_WMR_5F: U_WMR5F_swap(record, torev); break; + case U_WMR_60: U_WMR60_swap(record, torev); break; + case U_WMR_61: U_WMR61_swap(record, torev); break; + case U_WMR_62: U_WMR62_swap(record, torev); break; + case U_WMR_63: U_WMR63_swap(record, torev); break; + case U_WMR_64: U_WMR64_swap(record, torev); break; + case U_WMR_65: U_WMR65_swap(record, torev); break; + case U_WMR_66: U_WMR66_swap(record, torev); break; + case U_WMR_67: U_WMR67_swap(record, torev); break; + case U_WMR_68: U_WMR68_swap(record, torev); break; + case U_WMR_69: U_WMR69_swap(record, torev); break; + case U_WMR_6A: U_WMR6A_swap(record, torev); break; + case U_WMR_6B: U_WMR6B_swap(record, torev); break; + case U_WMR_6C: U_WMR6C_swap(record, torev); break; + case U_WMR_6D: U_WMR6D_swap(record, torev); break; + case U_WMR_6E: U_WMR6E_swap(record, torev); break; + case U_WMR_6F: U_WMR6F_swap(record, torev); break; + case U_WMR_70: U_WMR70_swap(record, torev); break; + case U_WMR_71: U_WMR71_swap(record, torev); break; + case U_WMR_72: U_WMR72_swap(record, torev); break; + case U_WMR_73: U_WMR73_swap(record, torev); break; + case U_WMR_74: U_WMR74_swap(record, torev); break; + case U_WMR_75: U_WMR75_swap(record, torev); break; + case U_WMR_76: U_WMR76_swap(record, torev); break; + case U_WMR_77: U_WMR77_swap(record, torev); break; + case U_WMR_78: U_WMR78_swap(record, torev); break; + case U_WMR_79: U_WMR79_swap(record, torev); break; + case U_WMR_7A: U_WMR7A_swap(record, torev); break; + case U_WMR_7B: U_WMR7B_swap(record, torev); break; + case U_WMR_7C: U_WMR7C_swap(record, torev); break; + case U_WMR_7D: U_WMR7D_swap(record, torev); break; + case U_WMR_7E: U_WMR7E_swap(record, torev); break; + case U_WMR_7F: U_WMR7F_swap(record, torev); break; + case U_WMR_80: U_WMR80_swap(record, torev); break; + case U_WMR_81: U_WMR81_swap(record, torev); break; + case U_WMR_82: U_WMR82_swap(record, torev); break; + case U_WMR_83: U_WMR83_swap(record, torev); break; + case U_WMR_84: U_WMR84_swap(record, torev); break; + case U_WMR_85: U_WMR85_swap(record, torev); break; + case U_WMR_86: U_WMR86_swap(record, torev); break; + case U_WMR_87: U_WMR87_swap(record, torev); break; + case U_WMR_88: U_WMR88_swap(record, torev); break; + case U_WMR_89: U_WMR89_swap(record, torev); break; + case U_WMR_8A: U_WMR8A_swap(record, torev); break; + case U_WMR_8B: U_WMR8B_swap(record, torev); break; + case U_WMR_8C: U_WMR8C_swap(record, torev); break; + case U_WMR_8D: U_WMR8D_swap(record, torev); break; + case U_WMR_8E: U_WMR8E_swap(record, torev); break; + case U_WMR_8F: U_WMR8F_swap(record, torev); break; + case U_WMR_90: U_WMR90_swap(record, torev); break; + case U_WMR_91: U_WMR91_swap(record, torev); break; + case U_WMR_92: U_WMR92_swap(record, torev); break; + case U_WMR_93: U_WMR93_swap(record, torev); break; + case U_WMR_94: U_WMR94_swap(record, torev); break; + case U_WMR_95: U_WMR95_swap(record, torev); break; + case U_WMR_96: U_WMR96_swap(record, torev); break; + case U_WMR_97: U_WMR97_swap(record, torev); break; + case U_WMR_98: U_WMR98_swap(record, torev); break; + case U_WMR_99: U_WMR99_swap(record, torev); break; + case U_WMR_9A: U_WMR9A_swap(record, torev); break; + case U_WMR_9B: U_WMR9B_swap(record, torev); break; + case U_WMR_9C: U_WMR9C_swap(record, torev); break; + case U_WMR_9D: U_WMR9D_swap(record, torev); break; + case U_WMR_9E: U_WMR9E_swap(record, torev); break; + case U_WMR_9F: U_WMR9F_swap(record, torev); break; + case U_WMR_A0: U_WMRA0_swap(record, torev); break; + case U_WMR_A1: U_WMRA1_swap(record, torev); break; + case U_WMR_A2: U_WMRA2_swap(record, torev); break; + case U_WMR_A3: U_WMRA3_swap(record, torev); break; + case U_WMR_A4: U_WMRA4_swap(record, torev); break; + case U_WMR_A5: U_WMRA5_swap(record, torev); break; + case U_WMR_A6: U_WMRA6_swap(record, torev); break; + case U_WMR_A7: U_WMRA7_swap(record, torev); break; + case U_WMR_A8: U_WMRA8_swap(record, torev); break; + case U_WMR_A9: U_WMRA9_swap(record, torev); break; + case U_WMR_AA: U_WMRAA_swap(record, torev); break; + case U_WMR_AB: U_WMRAB_swap(record, torev); break; + case U_WMR_AC: U_WMRAC_swap(record, torev); break; + case U_WMR_AD: U_WMRAD_swap(record, torev); break; + case U_WMR_AE: U_WMRAE_swap(record, torev); break; + case U_WMR_AF: U_WMRAF_swap(record, torev); break; + case U_WMR_B0: U_WMRB0_swap(record, torev); break; + case U_WMR_B1: U_WMRB1_swap(record, torev); break; + case U_WMR_B2: U_WMRB2_swap(record, torev); break; + case U_WMR_B3: U_WMRB3_swap(record, torev); break; + case U_WMR_B4: U_WMRB4_swap(record, torev); break; + case U_WMR_B5: U_WMRB5_swap(record, torev); break; + case U_WMR_B6: U_WMRB6_swap(record, torev); break; + case U_WMR_B7: U_WMRB7_swap(record, torev); break; + case U_WMR_B8: U_WMRB8_swap(record, torev); break; + case U_WMR_B9: U_WMRB9_swap(record, torev); break; + case U_WMR_BA: U_WMRBA_swap(record, torev); break; + case U_WMR_BB: U_WMRBB_swap(record, torev); break; + case U_WMR_BC: U_WMRBC_swap(record, torev); break; + case U_WMR_BD: U_WMRBD_swap(record, torev); break; + case U_WMR_BE: U_WMRBE_swap(record, torev); break; + case U_WMR_BF: U_WMRBF_swap(record, torev); break; + case U_WMR_C0: U_WMRC0_swap(record, torev); break; + case U_WMR_C1: U_WMRC1_swap(record, torev); break; + case U_WMR_C2: U_WMRC2_swap(record, torev); break; + case U_WMR_C3: U_WMRC3_swap(record, torev); break; + case U_WMR_C4: U_WMRC4_swap(record, torev); break; + case U_WMR_C5: U_WMRC5_swap(record, torev); break; + case U_WMR_C6: U_WMRC6_swap(record, torev); break; + case U_WMR_C7: U_WMRC7_swap(record, torev); break; + case U_WMR_C8: U_WMRC8_swap(record, torev); break; + case U_WMR_C9: U_WMRC9_swap(record, torev); break; + case U_WMR_CA: U_WMRCA_swap(record, torev); break; + case U_WMR_CB: U_WMRCB_swap(record, torev); break; + case U_WMR_CC: U_WMRCC_swap(record, torev); break; + case U_WMR_CD: U_WMRCD_swap(record, torev); break; + case U_WMR_CE: U_WMRCE_swap(record, torev); break; + case U_WMR_CF: U_WMRCF_swap(record, torev); break; + case U_WMR_D0: U_WMRD0_swap(record, torev); break; + case U_WMR_D1: U_WMRD1_swap(record, torev); break; + case U_WMR_D2: U_WMRD2_swap(record, torev); break; + case U_WMR_D3: U_WMRD3_swap(record, torev); break; + case U_WMR_D4: U_WMRD4_swap(record, torev); break; + case U_WMR_D5: U_WMRD5_swap(record, torev); break; + case U_WMR_D6: U_WMRD6_swap(record, torev); break; + case U_WMR_D7: U_WMRD7_swap(record, torev); break; + case U_WMR_D8: U_WMRD8_swap(record, torev); break; + case U_WMR_D9: U_WMRD9_swap(record, torev); break; + case U_WMR_DA: U_WMRDA_swap(record, torev); break; + case U_WMR_DB: U_WMRDB_swap(record, torev); break; + case U_WMR_DC: U_WMRDC_swap(record, torev); break; + case U_WMR_DD: U_WMRDD_swap(record, torev); break; + case U_WMR_DE: U_WMRDE_swap(record, torev); break; + case U_WMR_DF: U_WMRDF_swap(record, torev); break; + case U_WMR_E0: U_WMRE0_swap(record, torev); break; + case U_WMR_E1: U_WMRE1_swap(record, torev); break; + case U_WMR_E2: U_WMRE2_swap(record, torev); break; + case U_WMR_E3: U_WMRE3_swap(record, torev); break; + case U_WMR_E4: U_WMRE4_swap(record, torev); break; + case U_WMR_E5: U_WMRE5_swap(record, torev); break; + case U_WMR_E6: U_WMRE6_swap(record, torev); break; + case U_WMR_E7: U_WMRE7_swap(record, torev); break; + case U_WMR_E8: U_WMRE8_swap(record, torev); break; + case U_WMR_E9: U_WMRE9_swap(record, torev); break; + case U_WMR_EA: U_WMREA_swap(record, torev); break; + case U_WMR_EB: U_WMREB_swap(record, torev); break; + case U_WMR_EC: U_WMREC_swap(record, torev); break; + case U_WMR_ED: U_WMRED_swap(record, torev); break; + case U_WMR_EE: U_WMREE_swap(record, torev); break; + case U_WMR_EF: U_WMREF_swap(record, torev); break; + case U_WMR_DELETEOBJECT: U_WMRDELETEOBJECT_swap(record, torev); break; + case U_WMR_F1: U_WMRF1_swap(record, torev); break; + case U_WMR_F2: U_WMRF2_swap(record, torev); break; + case U_WMR_F3: U_WMRF3_swap(record, torev); break; + case U_WMR_F4: U_WMRF4_swap(record, torev); break; + case U_WMR_F5: U_WMRF5_swap(record, torev); break; + case U_WMR_F6: U_WMRF6_swap(record, torev); break; + case U_WMR_CREATEPALETTE: U_WMRCREATEPALETTE_swap(record, torev); break; + case U_WMR_F8: U_WMRF8_swap(record, torev); break; + case U_WMR_CREATEPATTERNBRUSH: U_WMRCREATEPATTERNBRUSH_swap(record, torev); break; + case U_WMR_CREATEPENINDIRECT: U_WMRCREATEPENINDIRECT_swap(record, torev); break; + case U_WMR_CREATEFONTINDIRECT: U_WMRCREATEFONTINDIRECT_swap(record, torev); break; + case U_WMR_CREATEBRUSHINDIRECT: U_WMRCREATEBRUSHINDIRECT_swap(record, torev); break; + case U_WMR_CREATEBITMAPINDIRECT: U_WMRCREATEBITMAPINDIRECT_swap(record, torev); break; + case U_WMR_CREATEBITMAP: U_WMRCREATEBITMAP_swap(record, torev); break; + case U_WMR_CREATEREGION: U_WMRCREATEREGION_swap(record, torev); break; + default: U_WMRNOTIMPLEMENTED_swap(record, torev); break; + } //end of switch + if(onerec)break; + record += 2*Size16; + offset += 2*Size16; + recnum++; + } //end of while + return(1); +} + + +#ifdef __cplusplus +} +#endif |