    /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    /*
     * This file is part of the LibreOffice project.
     *
     * This Source Code Form is subject to the terms of the Mozilla Public
     * License, v. 2.0. If a copy of the MPL was not distributed with this
     * file, You can obtain one at http://mozilla.org/MPL/2.0/.
     *
     * This file incorporates work covered by the following license notice:
     *
     *   Licensed to the Apache Software Foundation (ASF) under one or more
     *   contributor license agreements. See the NOTICE file distributed
     *   with this work for additional information regarding copyright
     *   ownership. The ASF licenses this file to you under the Apache
     *   License, Version 2.0 (the "License"); you may not use this file
     *   except in compliance with the License. You may obtain a copy of
     *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
     */

    #include <wmfreader.hxx>
    #include <emfreader.hxx>

    #include <memory>
    #include <boost/optional.hpp>
    #include <rtl/crc.h>
    #include <rtl/tencinfo.h>
    #include <sal/log.hxx>
    #include <osl/endian.h>
    #include <vcl/gdimtf.hxx>
    #include <vcl/svapp.hxx>
    #include <vcl/dibtools.hxx>
    #include <vcl/wmfexternal.hxx>
    #include <tools/fract.hxx>
    #include <o3tl/make_unique.hxx>
    #include <vcl/bitmapaccess.hxx>
    #include <vcl/BitmapTools.hxx>
    #include <osl/thread.h>

    // MS Windows defines
    #define W_META_SETBKCOLOR           0x0201
    #define W_META_SETBKMODE            0x0102
    #define W_META_SETMAPMODE           0x0103
    #define W_META_SETROP2              0x0104
    #define W_META_SETRELABS            0x0105
    #define W_META_SETPOLYFILLMODE      0x0106
    #define W_META_SETSTRETCHBLTMODE    0x0107
    #define W_META_SETTEXTCHAREXTRA     0x0108
    #define W_META_SETTEXTCOLOR         0x0209
    #define W_META_SETTEXTJUSTIFICATION 0x020A
    #define W_META_SETWINDOWORG         0x020B
    #define W_META_SETWINDOWEXT         0x020C
    #define W_META_SETVIEWPORTORG       0x020D
    #define W_META_SETVIEWPORTEXT       0x020E
    #define W_META_OFFSETWINDOWORG      0x020F
    #define W_META_SCALEWINDOWEXT       0x0410
    #define W_META_OFFSETVIEWPORTORG    0x0211
    #define W_META_SCALEVIEWPORTEXT     0x0412
    #define W_META_LINETO               0x0213
    #define W_META_MOVETO               0x0214
    #define W_META_EXCLUDECLIPRECT      0x0415
    #define W_META_INTERSECTCLIPRECT    0x0416
    #define W_META_ARC                  0x0817
    #define W_META_ELLIPSE              0x0418
    #define W_META_FLOODFILL            0x0419
    #define W_META_PIE                  0x081A
    #define W_META_RECTANGLE            0x041B
    #define W_META_ROUNDRECT            0x061C
    #define W_META_PATBLT               0x061D
    #define W_META_SAVEDC               0x001E
    #define W_META_SETPIXEL             0x041F
    #define W_META_OFFSETCLIPRGN        0x0220
    #define W_META_TEXTOUT              0x0521
    #define W_META_BITBLT               0x0922
    #define W_META_STRETCHBLT           0x0B23
    #define W_META_POLYGON              0x0324
    #define W_META_POLYLINE             0x0325
    #define W_META_ESCAPE               0x0626
    #define W_META_RESTOREDC            0x0127
    #define W_META_FILLREGION           0x0228
    #define W_META_FRAMEREGION          0x0429
    #define W_META_INVERTREGION         0x012A
    #define W_META_PAINTREGION          0x012B
    #define W_META_SELECTCLIPREGION     0x012C
    #define W_META_SELECTOBJECT         0x012D
    #define W_META_SETTEXTALIGN         0x012E
    #define W_META_DRAWTEXT             0x062F
    #define W_META_CHORD                0x0830
    #define W_META_SETMAPPERFLAGS       0x0231
    #define W_META_EXTTEXTOUT           0x0a32
    #define W_META_SETDIBTODEV          0x0d33
    #define W_META_SELECTPALETTE        0x0234
    #define W_META_REALIZEPALETTE       0x0035
    #define W_META_ANIMATEPALETTE       0x0436
    #define W_META_SETPALENTRIES        0x0037
    #define W_META_POLYPOLYGON          0x0538
    #define W_META_RESIZEPALETTE        0x0139
    #define W_META_DIBBITBLT            0x0940
    #define W_META_DIBSTRETCHBLT        0x0b41
    #define W_META_DIBCREATEPATTERNBRUSH 0x0142
    #define W_META_STRETCHDIB           0x0f43
    #define W_META_EXTFLOODFILL         0x0548
    #define W_META_RESETDC              0x014C
    #define W_META_STARTDOC             0x014D
    #define W_META_STARTPAGE            0x004F
    #define W_META_ENDPAGE              0x0050
    #define W_META_ABORTDOC             0x0052
    #define W_META_ENDDOC               0x005E
    #define W_META_DELETEOBJECT         0x01f0
    #define W_META_CREATEPALETTE        0x00f7
    #define W_META_CREATEBRUSH          0x00F8
    #define W_META_CREATEPATTERNBRUSH   0x01F9
    #define W_META_CREATEPENINDIRECT    0x02FA
    #define W_META_CREATEFONTINDIRECT   0x02FB
    #define W_META_CREATEBRUSHINDIRECT  0x02FC
    #define W_META_CREATEBITMAPINDIRECT 0x02FD
    #define W_META_CREATEBITMAP         0x06FE
    #define W_META_CREATEREGION         0x06FF

    namespace
    {
        void GetWinExtMax(const Point& rSource, tools::Rectangle& rPlaceableBound, const sal_Int16 nMapMode)
        {
            Point aSource(rSource);
            if (nMapMode == MM_HIMETRIC)
                aSource.setY( -rSource.Y() );
            if (aSource.X() < rPlaceableBound.Left())
                rPlaceableBound.SetLeft( aSource.X() );
            if (aSource.X() > rPlaceableBound.Right())
                rPlaceableBound.SetRight( aSource.X() );
            if (aSource.Y() < rPlaceableBound.Top())
                rPlaceableBound.SetTop( aSource.Y() );
            if (aSource.Y() > rPlaceableBound.Bottom())
                rPlaceableBound.SetBottom( aSource.Y() );
        }

        void GetWinExtMax(const tools::Rectangle& rSource, tools::Rectangle& rPlaceableBound, const sal_Int16 nMapMode)
        {
            GetWinExtMax(rSource.TopLeft(), rPlaceableBound, nMapMode);
            GetWinExtMax(rSource.BottomRight(), rPlaceableBound, nMapMode);
        }

    }

    namespace emfio
    {
        inline Point WmfReader::ReadPoint()
        {
            short nX = 0, nY = 0;
            mpInputStream->ReadInt16( nX ).ReadInt16( nY );
            return Point( nX, nY );
        }

        inline Point WmfReader::ReadYX()
        {
            short nX = 0, nY = 0;
            mpInputStream->ReadInt16( nY ).ReadInt16( nX );
            return Point( nX, nY );
        }

        tools::Rectangle WmfReader::ReadRectangle()
        {
            Point aBR, aTL;
            aBR = ReadYX();
            aTL = ReadYX();
            aBR.AdjustX( -1 );
            aBR.AdjustY( -1 );
            return tools::Rectangle( aTL, aBR );
        }

        Size WmfReader::ReadYXExt()
        {
            short nW=0, nH=0;
            mpInputStream->ReadInt16( nH ).ReadInt16( nW );
            return Size( nW, nH );
        }

        void WmfReader::ReadRecordParams( sal_uInt16 nFunc )
        {
            switch( nFunc )
            {
                case W_META_SETBKCOLOR:
                {
                    SetBkColor( ReadColor() );
                }
                break;

                case W_META_SETBKMODE:
                {
                    sal_uInt16 nDat = 0;
                    mpInputStream->ReadUInt16( nDat );
                    SetBkMode( static_cast<BkMode>(nDat) );
                }
                break;

                // !!!
                case W_META_SETMAPMODE:
                {
                    sal_Int16 nMapMode = 0;
                    mpInputStream->ReadInt16( nMapMode );
                    SetMapMode( nMapMode );
                }
                break;

                case W_META_SETROP2:
                {
                    sal_uInt16 nROP2 = 0;
                    mpInputStream->ReadUInt16( nROP2 );
                    SetRasterOp( static_cast<WMFRasterOp>(nROP2) );
                }
                break;

                case W_META_SETTEXTCOLOR:
                {
                    SetTextColor( ReadColor() );
                }
                break;

                case W_META_SETWINDOWORG:
                {
                    SetWinOrg( ReadYX() );
                }
                break;

                case W_META_SETWINDOWEXT:
                {
                    short nWidth = 0, nHeight = 0;
                    mpInputStream->ReadInt16( nHeight ).ReadInt16( nWidth );
                    SetWinExt( Size( nWidth, nHeight ) );
                }
                break;

                case W_META_OFFSETWINDOWORG:
                {
                    short nXAdd = 0, nYAdd = 0;
                    mpInputStream->ReadInt16( nYAdd ).ReadInt16( nXAdd );
                    SetWinOrgOffset( nXAdd, nYAdd );
                }
                break;

                case W_META_SCALEWINDOWEXT:
                {
                    short nXNum = 0, nXDenom = 0, nYNum = 0, nYDenom = 0;
                    mpInputStream->ReadInt16( nYDenom ).ReadInt16( nYNum ).ReadInt16( nXDenom ).ReadInt16( nXNum );
                    if (!nYDenom || !nXDenom)
                    {
                        mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                        break;
                    }
                    ScaleWinExt( static_cast<double>(nXNum) / nXDenom, static_cast<double>(nYNum) / nYDenom );
                }
                break;

                case W_META_SETVIEWPORTORG:
                case W_META_SETVIEWPORTEXT:
                break;

                case W_META_OFFSETVIEWPORTORG:
                {
                    short nXAdd = 0, nYAdd = 0;
                    mpInputStream->ReadInt16( nYAdd ).ReadInt16( nXAdd );
                    SetDevOrgOffset( nXAdd, nYAdd );
                }
                break;

                case W_META_SCALEVIEWPORTEXT:
                {
                    short nXNum = 0, nXDenom = 0, nYNum = 0, nYDenom = 0;
                    mpInputStream->ReadInt16( nYDenom ).ReadInt16( nYNum ).ReadInt16( nXDenom ).ReadInt16( nXNum );
                    if (!nYDenom || !nXDenom)
                    {
                        mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                        break;
                    }
                    ScaleDevExt( static_cast<double>(nXNum) / nXDenom, static_cast<double>(nYNum) / nYDenom );
                }
                break;

                case W_META_LINETO:
                {
                    LineTo( ReadYX() );
                }
                break;

                case W_META_MOVETO:
                {
                    MoveTo( ReadYX() );
                }
                break;

                case W_META_INTERSECTCLIPRECT:
                {
                    IntersectClipRect( ReadRectangle() );
                }
                break;

                case W_META_RECTANGLE:
                {
                    DrawRect( ReadRectangle() );
                }
                break;

                case W_META_ROUNDRECT:
                {
                    Size aSize( ReadYXExt() );
                    DrawRoundRect( ReadRectangle(), Size( aSize.Width() / 2, aSize.Height() / 2 ) );
                }
                break;

                case W_META_ELLIPSE:
                {
                    DrawEllipse( ReadRectangle() );
                }
                break;

                case W_META_ARC:
                {
                    Point aEnd( ReadYX() );
                    Point aStart( ReadYX() );
                    tools::Rectangle aRect( ReadRectangle() );
                    aRect.Justify();
                    DrawArc( aRect, aStart, aEnd );
                }
                break;

                case W_META_PIE:
                {
                    Point     aEnd( ReadYX() );
                    Point     aStart( ReadYX() );
                    tools::Rectangle aRect( ReadRectangle() );
                    aRect.Justify();

                    // #i73608# OutputDevice deviates from WMF
                    // semantics. start==end means full ellipse here.
                    if( aStart == aEnd )
                        DrawEllipse( aRect );
                    else
                        DrawPie( aRect, aStart, aEnd );
                }
                break;

                case W_META_CHORD:
                {
                    Point aEnd( ReadYX() );
                    Point aStart( ReadYX() );
                    tools::Rectangle aRect( ReadRectangle() );
                    aRect.Justify();
                    DrawChord( aRect, aStart, aEnd );
                }
                break;

                case W_META_POLYGON:
                {
                    bool bRecordOk = true;

                    sal_uInt16 nPoints(0);
                    mpInputStream->ReadUInt16(nPoints);

                    if (nPoints > mpInputStream->remainingSize() / (2 * sizeof(sal_uInt16)))
                    {
                        bRecordOk = false;
                    }
                    else
                    {
                        tools::Polygon aPoly(nPoints);
                        for (sal_uInt16 i(0); i < nPoints && mpInputStream->good(); ++i)
                            aPoly[ i ] = ReadPoint();
                        DrawPolygon(aPoly, false/*bRecordPath*/);
                    }

                    SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polygon record has more points than we can handle");

                    bRecordOk &= mpInputStream->good();

                    if (!bRecordOk)
                    {
                        mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                        break;
                    }
                }
                break;

                case W_META_POLYPOLYGON:
                {
                    sal_uInt16 nPolyCount(0);
                    // Number of polygons:
                    mpInputStream->ReadUInt16( nPolyCount );
                    if (nPolyCount && mpInputStream->good())
                    {
                        bool bRecordOk = true;
                        if (nPolyCount > mpInputStream->remainingSize() / sizeof(sal_uInt16))
                        {
                            break;
                        }

                        // Number of points of each polygon. Determine total number of points
                        std::unique_ptr<sal_uInt16[]> xPolygonPointCounts(new sal_uInt16[nPolyCount]);
                        sal_uInt16* pnPoints = xPolygonPointCounts.get();
                        tools::PolyPolygon aPolyPoly(nPolyCount);
                        sal_uInt16 nPoints = 0;
                        for (sal_uInt16 a = 0; a < nPolyCount && mpInputStream->good(); ++a)
                        {
                            mpInputStream->ReadUInt16( pnPoints[a] );

                            if (pnPoints[a] > SAL_MAX_UINT16 - nPoints)
                            {
                                bRecordOk = false;
                                break;
                            }

                            nPoints += pnPoints[a];
                        }

                        SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polypolygon record has more polygons than we can handle");

                        bRecordOk &= mpInputStream->good();

                        if (!bRecordOk)
                        {
                            mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                            break;
                        }

                        // Polygon points are:
                        for (sal_uInt16 a = 0; a < nPolyCount && mpInputStream->good(); ++a)
                        {
                            const sal_uInt16 nPointCount(pnPoints[a]);

                            if (nPointCount > mpInputStream->remainingSize() / (2 * sizeof(sal_uInt16)))
                            {
                                bRecordOk = false;
                                break;
                            }

                            std::unique_ptr<Point[]> xPolygonPoints(new Point[nPointCount]);
                            Point* pPtAry = xPolygonPoints.get();

                            for(sal_uInt16 b(0); b < nPointCount && mpInputStream->good(); ++b)
                            {
                                pPtAry[b] = ReadPoint();
                            }

                            aPolyPoly.Insert( tools::Polygon(nPointCount, pPtAry) );
                        }

                        bRecordOk &= mpInputStream->good();

                        if (!bRecordOk)
                        {
                            mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                            break;
                        }

                        DrawPolyPolygon( aPolyPoly );
                    }
                }
                break;

                case W_META_POLYLINE:
                {
                    bool bRecordOk = true;

                    sal_uInt16 nPoints(0);
                    mpInputStream->ReadUInt16(nPoints);

                    if (nPoints > mpInputStream->remainingSize() / (2 * sizeof(sal_uInt16)))
                    {
                        bRecordOk = false;
                    }
                    else
                    {
                        tools::Polygon aPoly(nPoints);
                        for (sal_uInt16 i(0); i < nPoints && mpInputStream->good(); ++i)
                            aPoly[ i ] = ReadPoint();
                        DrawPolyLine( aPoly );
                    }

                    SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polyline record has more points than we can handle");

                    bRecordOk &= mpInputStream->good();

                    if (!bRecordOk)
                    {
                        mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                        break;
                    }
                }
                break;

                case W_META_SAVEDC:
                {
                    Push();
                }
                break;

                case W_META_RESTOREDC:
                {
                    Pop();
                }
                break;

                case W_META_SETPIXEL:
                {
                    const Color aColor = ReadColor();
                    DrawPixel( ReadYX(), aColor );
                }
                break;

                case W_META_OFFSETCLIPRGN:
                {
                    MoveClipRegion( ReadYXExt() );
                }
                break;

                case W_META_TEXTOUT:
                {
                    //record is Recordsize, RecordFunction, StringLength, <String>, YStart, XStart
                    const sal_uInt32 nNonStringLen = sizeof(sal_uInt32) + 4 * sizeof(sal_uInt16);
                    const sal_uInt32 nRecSize = mnRecSize * 2;

                    if (nRecSize < nNonStringLen)
                    {
                        SAL_WARN("vcl.wmf", "W_META_TEXTOUT too short");
                        break;
                    }

                    sal_uInt16 nLength = 0;
                    mpInputStream->ReadUInt16(nLength);
                    sal_uInt16 nStoredLength = (nLength + 1) &~ 1;

                    if (nRecSize - nNonStringLen < nStoredLength)
                    {
                        SAL_WARN("vcl.wmf", "W_META_TEXTOUT too short, truncating string");
                        nLength = nStoredLength = nRecSize - nNonStringLen;
                    }

                    if (nLength)
                    {
                        std::vector<char> aChars(nStoredLength);
                        nLength = std::min<sal_uInt16>(nLength, mpInputStream->ReadBytes(aChars.data(), aChars.size()));
                        OUString aText(aChars.data(), nLength, GetCharSet());
                        Point aPosition( ReadYX() );
                        DrawText( aPosition, aText );
                    }
                }
                break;

                case W_META_EXTTEXTOUT:
                {
                    //record is Recordsize, RecordFunction, Y, X, StringLength, options, maybe rectangle, <String>
                    sal_uInt32 nNonStringLen = sizeof(sal_uInt32) + 5 * sizeof(sal_uInt16);
                    const sal_uInt32 nRecSize = mnRecSize * 2;

                    if (nRecSize < nNonStringLen)
                    {
                        SAL_WARN("vcl.wmf", "W_META_EXTTEXTOUT too short");
                        break;
                    }

                    auto nRecordPos = mpInputStream->Tell() - 6;
                    Point aPosition = ReadYX();
                    sal_uInt16 nLen = 0, nOptions = 0;
                    mpInputStream->ReadUInt16( nLen ).ReadUInt16( nOptions );

                    if (nOptions & ETO_CLIPPED)
                    {
                        nNonStringLen += 2 * sizeof(sal_uInt16);

                        if (nRecSize < nNonStringLen)
                        {
                            SAL_WARN("vcl.wmf", "W_META_TEXTOUT too short");
                            break;
                        }

                        ReadPoint();
                        ReadPoint();
                        SAL_WARN("vcl.wmf", "clipping unsupported");
                    }

                    ComplexTextLayoutFlags nTextLayoutMode = ComplexTextLayoutFlags::Default;
                    if ( nOptions & ETO_RTLREADING )
                        nTextLayoutMode = ComplexTextLayoutFlags::BiDiRtl | ComplexTextLayoutFlags::TextOriginLeft;
                    SetTextLayoutMode( nTextLayoutMode );
                    SAL_WARN_IF( ( nOptions & ( ETO_PDY | ETO_GLYPH_INDEX ) ) != 0, "vcl.wmf", "SJ: ETO_PDY || ETO_GLYPH_INDEX in WMF" );

                    // output only makes sense if the text contains characters
                    if (nLen)
                    {
                        sal_Int32 nOriginalTextLen = nLen;
                        sal_Int32 nOriginalBlockLen = ( nOriginalTextLen + 1 ) &~ 1;

                        auto nMaxStreamPos = nRecordPos + nRecSize;
                        auto nRemainingSize = std::min(mpInputStream->remainingSize(), nMaxStreamPos - mpInputStream->Tell());
                        if (nRemainingSize < static_cast<sal_uInt32>(nOriginalBlockLen))
                        {
                            SAL_WARN("vcl.wmf", "exttextout record claimed more data than the stream can provide");
                            nOriginalTextLen = nOriginalBlockLen = nRemainingSize;
                        }

                        std::unique_ptr<char[]> pChar(new char[nOriginalBlockLen]);
                        mpInputStream->ReadBytes(pChar.get(), nOriginalBlockLen);
                        OUString aText(pChar.get(), nOriginalTextLen, GetCharSet()); // after this conversion the text may contain
                        sal_Int32 nNewTextLen = aText.getLength();                         // less character (japanese version), so the
                                                                                           // dxAry will not fit
                        if ( nNewTextLen )
                        {
                            std::unique_ptr<long[]> pDXAry, pDYAry;
                            auto nDxArySize =  nMaxStreamPos - mpInputStream->Tell();
                            auto nDxAryEntries = nDxArySize >> 1;
                            bool        bUseDXAry = false;

                            if ( ( ( nDxAryEntries % nOriginalTextLen ) == 0 ) && ( nNewTextLen <= nOriginalTextLen ) )
                            {
                                sal_Int32 i; // needed just outside the for
                                pDXAry.reset(new long[ nNewTextLen ]);
                                if ( nOptions & ETO_PDY )
                                {
                                    pDYAry.reset(new long[ nNewTextLen ]);
                                }
                                for (i = 0; i < nNewTextLen; i++ )
                                {
                                    if ( mpInputStream->Tell() >= nMaxStreamPos )
                                        break;
                                    sal_Int32 nDxCount = 1;
                                    if ( nNewTextLen != nOriginalTextLen )
                                    {
                                        sal_Unicode cUniChar = aText[i];
                                        OString aTmp(&cUniChar, 1, GetCharSet());
                                        if ( aTmp.getLength() > 1 )
                                        {
                                            nDxCount = aTmp.getLength();
                                        }
                                    }

                                    sal_Int16 nDx = 0, nDy = 0;
                                    while ( nDxCount-- )
                                    {
                                        if ( ( mpInputStream->Tell() + 2 ) > nMaxStreamPos )
                                            break;
                                        sal_Int16 nDxTmp = 0;
                                        mpInputStream->ReadInt16(nDxTmp);
                                        nDx += nDxTmp;
                                        if ( nOptions & ETO_PDY )
                                        {
                                            if ( ( mpInputStream->Tell() + 2 ) > nMaxStreamPos )
                                                break;
                                            sal_Int16 nDyTmp = 0;
                                            mpInputStream->ReadInt16(nDyTmp);
                                            nDy += nDyTmp;
                                        }
                                    }

                                    pDXAry[ i ] = nDx;
                                    if ( nOptions & ETO_PDY )
                                    {
                                        pDYAry[i] = nDy;
                                    }
                                }
                                if ( i == nNewTextLen )
                                    bUseDXAry = true;
                            }
                            if ( pDXAry && bUseDXAry )
                                DrawText( aPosition, aText, pDXAry.get(), pDYAry.get() );
                            else
                                DrawText( aPosition, aText );
                        }
                    }
                }
                break;

                case W_META_SELECTOBJECT:
                {
                    sal_Int16   nObjIndex = 0;
                    mpInputStream->ReadInt16( nObjIndex );
                    SelectObject( nObjIndex );
                }
                break;

                case W_META_SETTEXTALIGN:
                {
                    sal_uInt16  nAlign = 0;
                    mpInputStream->ReadUInt16( nAlign );
                    SetTextAlign( nAlign );
                }
                break;

                case W_META_BITBLT:
                {
                    // 0-3   : nWinROP                      #93454#
                    // 4-5   : y offset of source bitmap
                    // 6-7   : x offset of source bitmap
                    // 8-9   : used height of source bitmap
                    // 10-11 : used width  of source bitmap
                    // 12-13 : destination position y (in pixel)
                    // 14-15 : destination position x (in pixel)
                    // 16-17 : don't know
                    // 18-19 : Width Bitmap in Pixel
                    // 20-21 : Height Bitmap in Pixel
                    // 22-23 : bytes per scanline
                    // 24    : planes
                    // 25    : bitcount

                    sal_Int32   nWinROP = 0;
                    sal_uInt16  nSx = 0, nSy = 0, nSxe = 0, nSye = 0, nDontKnow = 0, nWidth = 0, nHeight = 0, nBytesPerScan = 0;
                    sal_uInt8   nPlanes, nBitCount;

                    mpInputStream->ReadInt32( nWinROP )
                         .ReadUInt16( nSy ).ReadUInt16( nSx ).ReadUInt16( nSye ).ReadUInt16( nSxe );
                    Point aPoint( ReadYX() );
                    mpInputStream->ReadUInt16( nDontKnow ).ReadUInt16( nWidth ).ReadUInt16( nHeight ).ReadUInt16( nBytesPerScan ).ReadUChar( nPlanes ).ReadUChar( nBitCount );

                    bool bOk = nWidth && nHeight && nPlanes == 1 && nBitCount == 1 && nBytesPerScan != 0;
                    if (bOk)
                    {
                        bOk = nBytesPerScan <= mpInputStream->remainingSize() / nHeight;
                    }
                    if (bOk)
                    {
                        vcl::bitmap::RawBitmap aBmp( Size( nWidth, nHeight ), 24 );
                        for (sal_uInt16 y = 0; y < nHeight && mpInputStream->good(); ++y)
                        {
                            sal_uInt16 x = 0;
                            for (sal_uInt16 scan = 0; scan < nBytesPerScan; scan++ )
                            {
                                sal_Int8 nEightPixels = 0;
                                mpInputStream->ReadSChar( nEightPixels );
                                for (sal_Int8 i = 7; i >= 0; i-- )
                                {
                                    if ( x < nWidth )
                                    {
                                        aBmp.SetPixel( y, x, ((nEightPixels>>i)&1) ? COL_BLACK : COL_WHITE );
                                    }
                                    x++;
                                }
                            }
                        }
                        BitmapEx aBitmap = vcl::bitmap::CreateFromData(std::move(aBmp));
                        if ( nSye && nSxe &&
                             ( nSx + nSxe <= nWidth ) &&
                             ( nSy + nSye <= nHeight ) )
                        {
                            tools::Rectangle aCropRect( Point( nSx, nSy ), Size( nSxe, nSye ) );
                            aBitmap.Crop( aCropRect );
                        }
                        tools::Rectangle aDestRect( aPoint, Size( nSxe, nSye ) );
                        maBmpSaveList.emplace_back(new BSaveStruct(aBitmap, aDestRect, nWinROP));
                    }
                }
                break;

                case W_META_STRETCHBLT:
                case W_META_DIBBITBLT:
                case W_META_DIBSTRETCHBLT:
                case W_META_STRETCHDIB:
                {
                    sal_Int32   nWinROP = 0;
                    sal_uInt16  nSx = 0, nSy = 0, nSxe = 0, nSye = 0, nUsage = 0;
                    Bitmap      aBmp;

                    mpInputStream->ReadInt32( nWinROP );

                    if( nFunc == W_META_STRETCHDIB )
                        mpInputStream->ReadUInt16( nUsage );

                    // nSye and nSxe is the number of pixels that has to been used
                    // If they are set to zero, it is as indicator not to scale the bitmap later

                    if( nFunc == W_META_STRETCHDIB || nFunc == W_META_STRETCHBLT || nFunc == W_META_DIBSTRETCHBLT )
                        mpInputStream->ReadUInt16( nSye ).ReadUInt16( nSxe );

                    // nSy and nx is the offset of the first pixel
                    mpInputStream->ReadUInt16( nSy ).ReadUInt16( nSx );

                    if( nFunc == W_META_STRETCHDIB || nFunc == W_META_DIBBITBLT || nFunc == W_META_DIBSTRETCHBLT )
                    {
                        if ( nWinROP == PATCOPY )
                            mpInputStream->ReadUInt16( nUsage );    // i don't know anything of this parameter, so its called nUsage
                                                // DrawRect( Rectangle( ReadYX(), aDestSize ), false );

                        Size aDestSize( ReadYXExt() );
                        if ( aDestSize.Width() && aDestSize.Height() )  // #92623# do not try to read buggy bitmaps
                        {
                            tools::Rectangle aDestRect( ReadYX(), aDestSize );
                            if ( nWinROP != PATCOPY )
                                ReadDIB(aBmp, *mpInputStream, false);

                            // test if it is sensible to crop
                            if ( nSye && nSxe &&
                                 ( nSx + nSxe <= aBmp.GetSizePixel().Width() ) &&
                                 ( nSy + nSye <= aBmp.GetSizePixel().Height() ) )
                            {
                                tools::Rectangle aCropRect( Point( nSx, nSy ), Size( nSxe, nSye ) );
                                aBmp.Crop( aCropRect );
                            }
                            maBmpSaveList.emplace_back(new BSaveStruct(aBmp, aDestRect, nWinROP));
                        }
                    }
                }
                break;

                case W_META_DIBCREATEPATTERNBRUSH:
                {
                    Bitmap  aBmp;
                    sal_uInt32  nRed = 0, nGreen = 0, nBlue = 0, nCount = 1;
                    sal_uInt16  nFunction = 0;

                    mpInputStream->ReadUInt16( nFunction ).ReadUInt16( nFunction );

                    ReadDIB(aBmp, *mpInputStream, false);
                    if ( !!aBmp )
                    {
                        Bitmap::ScopedReadAccess pBmp(aBmp);
                        for ( long y = 0; y < pBmp->Height(); y++ )
                        {
                            for ( long x = 0; x < pBmp->Width(); x++ )
                            {
                                const BitmapColor aColor( pBmp->GetColor( y, x ) );

                                nRed += aColor.GetRed();
                                nGreen += aColor.GetGreen();
                                nBlue += aColor.GetBlue();
                            }
                        }
                        nCount = pBmp->Height() * pBmp->Width();
                        if ( !nCount )
                            nCount++;
                    }
                    Color aColor( static_cast<sal_uInt8>( nRed / nCount ), static_cast<sal_uInt8>( nGreen / nCount ), static_cast<sal_uInt8>( nBlue / nCount ) );
                    CreateObject(o3tl::make_unique<WinMtfFillStyle>( aColor, false ));
                }
                break;

                case W_META_DELETEOBJECT:
                {
                    sal_Int16 nIndex = 0;
                    mpInputStream->ReadInt16( nIndex );
                    DeleteObject( nIndex );
                }
                break;

                case W_META_CREATEPALETTE:
                {
                    CreateObject();
                }
                break;

                case W_META_CREATEBRUSH:
                {
                    CreateObject(o3tl::make_unique<WinMtfFillStyle>( COL_WHITE, false ));
                }
                break;

                case W_META_CREATEPATTERNBRUSH:
                {
                    CreateObject(o3tl::make_unique<WinMtfFillStyle>( COL_WHITE, false ));
                }
                break;

                case W_META_CREATEPENINDIRECT:
                {
                    LineInfo   aLineInfo;
                    sal_uInt16 nStyle = 0;
                    sal_uInt16 nWidth = 0;
                    sal_uInt16 nHeight = 0;

                    mpInputStream->ReadUInt16(nStyle);
                    mpInputStream->ReadUInt16(nWidth);
                    mpInputStream->ReadUInt16(nHeight);

                    if (nWidth > 0)
                        aLineInfo.SetWidth(nWidth);

                    bool bTransparent = false;

                    switch( nStyle & 0xFF )
                    {
                        case PS_DASHDOTDOT :
                            aLineInfo.SetStyle( LineStyle::Dash );
                            aLineInfo.SetDashCount( 1 );
                            aLineInfo.SetDotCount( 2 );
                        break;
                        case PS_DASHDOT :
                            aLineInfo.SetStyle( LineStyle::Dash );
                            aLineInfo.SetDashCount( 1 );
                            aLineInfo.SetDotCount( 1 );
                        break;
                        case PS_DOT :
                            aLineInfo.SetStyle( LineStyle::Dash );
                            aLineInfo.SetDashCount( 0 );
                            aLineInfo.SetDotCount( 1 );
                        break;
                        case PS_DASH :
                            aLineInfo.SetStyle( LineStyle::Dash );
                            aLineInfo.SetDashCount( 1 );
                            aLineInfo.SetDotCount( 0 );
                        break;
                        case PS_NULL :
                            bTransparent = true;
                            aLineInfo.SetStyle( LineStyle::NONE );
                        break;
                        default :
                        case PS_INSIDEFRAME :
                        case PS_SOLID :
                            aLineInfo.SetStyle( LineStyle::Solid );
                    }
                    switch( nStyle & 0xF00 )
                    {
                        case PS_ENDCAP_ROUND :
                            aLineInfo.SetLineCap( css::drawing::LineCap_ROUND );
                        break;
                        case PS_ENDCAP_SQUARE :
                            aLineInfo.SetLineCap( css::drawing::LineCap_SQUARE );
                        break;
                        case PS_ENDCAP_FLAT :
                        default :
                            aLineInfo.SetLineCap( css::drawing::LineCap_BUTT );
                    }
                    switch( nStyle & 0xF000 )
                    {
                        case PS_JOIN_ROUND :
                            aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Round );
                        break;
                        case PS_JOIN_MITER :
                            aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Miter );
                        break;
                        case PS_JOIN_BEVEL :
                            aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::Bevel );
                        break;
                        default :
                            aLineInfo.SetLineJoin ( basegfx::B2DLineJoin::NONE );
                    }
                    CreateObject(o3tl::make_unique<WinMtfLineStyle>( ReadColor(), aLineInfo, bTransparent ));
                }
                break;

                case W_META_CREATEBRUSHINDIRECT:
                {
                    sal_uInt16  nStyle = 0;
                    mpInputStream->ReadUInt16( nStyle );
                    CreateObject(o3tl::make_unique<WinMtfFillStyle>( ReadColor(), ( nStyle == BS_HOLLOW ) ));
                }
                break;

                case W_META_CREATEFONTINDIRECT:
                {
                    Size aFontSize;
                    char lfFaceName[LF_FACESIZE+1];
                    sal_Int16 lfEscapement = 0;
                    sal_Int16 lfOrientation = 0;
                    sal_Int16 lfWeight = 0;

                    LOGFONTW aLogFont;
                    aFontSize = ReadYXExt();
                    mpInputStream->ReadInt16( lfEscapement );
                    mpInputStream->ReadInt16( lfOrientation );
                    mpInputStream->ReadInt16( lfWeight );
                    mpInputStream->ReadUChar( aLogFont.lfItalic );
                    mpInputStream->ReadUChar( aLogFont.lfUnderline );
                    mpInputStream->ReadUChar( aLogFont.lfStrikeOut );
                    mpInputStream->ReadUChar( aLogFont.lfCharSet );
                    mpInputStream->ReadUChar( aLogFont.lfOutPrecision );
                    mpInputStream->ReadUChar( aLogFont.lfClipPrecision );
                    mpInputStream->ReadUChar( aLogFont.lfQuality );
                    mpInputStream->ReadUChar( aLogFont.lfPitchAndFamily );
                    size_t nRet = mpInputStream->ReadBytes( lfFaceName, LF_FACESIZE );
                    lfFaceName[nRet] = 0;
                    aLogFont.lfWidth = aFontSize.Width();
                    aLogFont.lfHeight = aFontSize.Height();
                    aLogFont.lfEscapement = lfEscapement;
                    aLogFont.lfOrientation = lfOrientation;
                    aLogFont.lfWeight = lfWeight;

                    rtl_TextEncoding eCharSet;
                    if ( ( aLogFont.lfCharSet == OEM_CHARSET ) || ( aLogFont.lfCharSet == DEFAULT_CHARSET ) )
                        eCharSet = osl_getThreadTextEncoding();
                    else
                        eCharSet = rtl_getTextEncodingFromWindowsCharset( aLogFont.lfCharSet );
                    if ( eCharSet == RTL_TEXTENCODING_DONTKNOW )
                        eCharSet = osl_getThreadTextEncoding();
                    if ( eCharSet == RTL_TEXTENCODING_SYMBOL )
                        eCharSet = RTL_TEXTENCODING_MS_1252;
                    aLogFont.alfFaceName = OUString( lfFaceName, strlen(lfFaceName), eCharSet );

                    CreateObject(o3tl::make_unique<WinMtfFontStyle>( aLogFont ));
                }
                break;

                case W_META_CREATEBITMAPINDIRECT:
                {
                    CreateObject();
                }
                break;

                case W_META_CREATEBITMAP:
                {
                    CreateObject();
                }
                break;

                case W_META_CREATEREGION:
                {
                    CreateObject();
                }
                break;

                case W_META_EXCLUDECLIPRECT :
                {
                    ExcludeClipRect( ReadRectangle() );
                }
                break;

                case W_META_PATBLT:
                {
                    sal_uInt32 nROP = 0;
                    WMFRasterOp nOldROP = WMFRasterOp::NONE;
                    mpInputStream->ReadUInt32( nROP );
                    Size aSize = ReadYXExt();
                    nOldROP = SetRasterOp( static_cast<WMFRasterOp>(nROP) );
                    DrawRect( tools::Rectangle( ReadYX(), aSize ), false );
                    SetRasterOp( nOldROP );
                }
                break;

                case W_META_SELECTCLIPREGION:
                {
                    sal_Int16 nObjIndex = 0;
                    mpInputStream->ReadInt16( nObjIndex );
                    if ( !nObjIndex )
                    {
                        tools::PolyPolygon aEmptyPolyPoly;
                        SetClipPath( aEmptyPolyPoly, RGN_COPY, true );
                    }
                }
                break;

                case W_META_ESCAPE :
                {
                    // mnRecSize has been checked previously to be greater than 3
                    sal_uInt64 nMetaRecSize = static_cast< sal_uInt64 >(mnRecSize - 2 ) * 2;
                    sal_uInt64 nMetaRecEndPos = mpInputStream->Tell() + nMetaRecSize;

                    // taking care that mnRecSize does not exceed the maximal stream position
                    if ( nMetaRecEndPos > mnEndPos )
                    {
                        mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                        break;
                    }
                    if (mnRecSize >= 4 )    // minimal escape length
                    {
                        sal_uInt16  nMode = 0, nLen = 0;
                        mpInputStream->ReadUInt16( nMode )
                             .ReadUInt16( nLen );
                        if ( ( nMode == W_MFCOMMENT ) && ( nLen >= 4 ) )
                        {
                            sal_uInt32 nNewMagic = 0; // we have to read int32 for
                            mpInputStream->ReadUInt32( nNewMagic );   // META_ESCAPE_ENHANCED_METAFILE CommentIdentifier

                            if( nNewMagic == 0x2c2a4f4f &&  nLen >= 14 )
                            {
                                sal_uInt16 nMagic2 = 0;
                                mpInputStream->ReadUInt16( nMagic2 );
                                if( nMagic2 == 0x0a ) // 2nd half of magic
                                {                     // continue with private escape
                                    sal_uInt32 nCheck = 0, nEsc = 0;
                                    mpInputStream->ReadUInt32( nCheck )
                                         .ReadUInt32( nEsc );

                                    sal_uInt32 nEscLen = nLen - 14;
                                    if ( nEscLen <= (mnRecSize * 2 ) )
                                    {
        #ifdef OSL_BIGENDIAN
                                        sal_uInt32 nTmp = OSL_SWAPDWORD( nEsc );
                                        sal_uInt32 nCheckSum = rtl_crc32( 0, &nTmp, 4 );
        #else
                                        sal_uInt32 nCheckSum = rtl_crc32( 0, &nEsc, 4 );
        #endif
                                        std::unique_ptr<sal_Int8[]> pData;

                                        if ( ( static_cast< sal_uInt64 >( nEscLen ) + mpInputStream->Tell() ) > nMetaRecEndPos )
                                        {
                                            mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                                            break;
                                        }
                                        if ( nEscLen > 0 )
                                        {
                                            pData.reset(new sal_Int8[ nEscLen ]);
                                            mpInputStream->ReadBytes(pData.get(), nEscLen);
                                            nCheckSum = rtl_crc32( nCheckSum, pData.get(), nEscLen );
                                        }
                                        if ( nCheck == nCheckSum )
                                        {
                                            switch( nEsc )
                                            {
                                                case PRIVATE_ESCAPE_UNICODE :
                                                {
                                                    // we will use text instead of polygons only if we have the correct font
                                                    if ( Application::GetDefaultDevice()->IsFontAvailable( GetFont().GetFamilyName() ) )
                                                    {
                                                        Point  aPt;
                                                        OUString aString;
                                                        sal_uInt32  nStringLen, nDXCount;
                                                        std::unique_ptr<long[]> pDXAry;
                                                        SvMemoryStream aMemoryStream( nEscLen );
                                                        aMemoryStream.WriteBytes(pData.get(), nEscLen);
                                                        aMemoryStream.Seek( STREAM_SEEK_TO_BEGIN );
                                                        sal_Int32 nTmpX(0), nTmpY(0);
                                                        aMemoryStream.ReadInt32( nTmpX )
                                                                     .ReadInt32( nTmpY )
                                                                     .ReadUInt32( nStringLen );
                                                         aPt.setX( nTmpX );
                                                         aPt.setY( nTmpY );

                                                        if ( ( static_cast< sal_uInt64 >( nStringLen ) * sizeof( sal_Unicode ) ) < ( nEscLen - aMemoryStream.Tell() ) )
                                                        {

                                                            aString = read_uInt16s_ToOUString(aMemoryStream, nStringLen);
                                                            aMemoryStream.ReadUInt32( nDXCount );
                                                            if ( ( static_cast< sal_uInt64 >( nDXCount ) * sizeof( sal_Int32 ) ) >= ( nEscLen - aMemoryStream.Tell() ) )
                                                                nDXCount = 0;
                                                            if ( nDXCount )
                                                                pDXAry.reset(new long[ nDXCount ]);
                                                            for  (sal_uInt32 i = 0; i < nDXCount; i++ )
                                                            {
                                                                sal_Int32 val;
                                                                aMemoryStream.ReadInt32( val);
                                                                pDXAry[ i ] = val;
                                                            }
                                                            aMemoryStream.ReadUInt32(mnSkipActions);
                                                            DrawText( aPt, aString, pDXAry.get() );
                                                        }
                                                    }
                                                }
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                            else if ( (nNewMagic == static_cast< sal_uInt32 >(0x43464D57)) && (nLen >= 34) && ( static_cast<sal_Int32>(nLen + 10) <= static_cast<sal_Int32>(mnRecSize * 2) ))
                            {
                                sal_uInt32 nComType = 0, nVersion = 0, nFlags = 0, nComRecCount = 0,
                                           nCurRecSize = 0, nRemainingSize = 0, nEMFTotalSize = 0;
                                sal_uInt16 nCheck = 0;

                                mpInputStream->ReadUInt32( nComType ).ReadUInt32( nVersion ).ReadUInt16( nCheck ).ReadUInt32( nFlags )
                                     .ReadUInt32( nComRecCount ).ReadUInt32( nCurRecSize )
                                     .ReadUInt32( nRemainingSize ).ReadUInt32( nEMFTotalSize ); // the nRemainingSize is not mentioned in MSDN documentation
                                                                          // but it seems to be required to read in data produced by OLE

                                if( nComType == 0x01 && nVersion == 0x10000 && nComRecCount )
                                {
                                    if( !mnEMFRec)
                                    {   // first EMF comment
                                        mnEMFRecCount = nComRecCount;
                                        mnEMFSize = nEMFTotalSize;
                                        if (mnEMFSize > mpInputStream->remainingSize())
                                        {
                                            SAL_WARN("vcl.wmf", "emf size claims to be larger than remaining data");
                                            mpEMFStream.reset();
                                        }
                                        else
                                            mpEMFStream = o3tl::make_unique<SvMemoryStream>(mnEMFSize, 0);
                                    }
                                    else if( (mnEMFRecCount != nComRecCount ) || (mnEMFSize != nEMFTotalSize ) ) // add additional checks here
                                    {
                                        // total records should be the same as in previous comments
                                        mnEMFRecCount = 0xFFFFFFFF;
                                        mpEMFStream.reset();
                                    }
                                    mnEMFRec++;

                                    if (mpEMFStream && nCurRecSize + 34 > nLen)
                                    {
                                        mnEMFRecCount = 0xFFFFFFFF;
                                        mpEMFStream.reset();
                                    }

                                    if (mpEMFStream && nCurRecSize > mpInputStream->remainingSize())
                                    {
                                        SAL_WARN("vcl.wmf", "emf record size claims to be larger than remaining data");
                                        mnEMFRecCount = 0xFFFFFFFF;
                                        mpEMFStream.reset();
                                    }

                                    if (mpEMFStream)
                                    {
                                        std::vector<sal_Int8> aBuf(nCurRecSize);
                                        sal_uInt32 nCount = mpInputStream->ReadBytes(aBuf.data(), nCurRecSize);
                                        if( nCount == nCurRecSize )
                                            mpEMFStream->WriteBytes(aBuf.data(), nCount);
                                    }
                                }
                            }
                        }
                    }
                }
                break;

                case W_META_SETRELABS:
                case W_META_SETPOLYFILLMODE:
                case W_META_SETSTRETCHBLTMODE:
                case W_META_SETTEXTCHAREXTRA:
                case W_META_SETTEXTJUSTIFICATION:
                case W_META_FLOODFILL :
                case W_META_FILLREGION:
                case W_META_FRAMEREGION:
                case W_META_INVERTREGION:
                case W_META_PAINTREGION:
                case W_META_DRAWTEXT:
                case W_META_SETMAPPERFLAGS:
                case W_META_SETDIBTODEV:
                case W_META_SELECTPALETTE:
                case W_META_REALIZEPALETTE:
                case W_META_ANIMATEPALETTE:
                case W_META_SETPALENTRIES:
                case W_META_RESIZEPALETTE:
                case W_META_EXTFLOODFILL:
                case W_META_RESETDC:
                case W_META_STARTDOC:
                case W_META_STARTPAGE:
                case W_META_ENDPAGE:
                case W_META_ABORTDOC:
                case W_META_ENDDOC:
                break;
            }
        }

        static const long   aMaxWidth = 1024;

        bool WmfReader::ReadHeader()
        {
            sal_uInt64 const nStrmPos = mpInputStream->Tell();

            sal_uInt32 nPlaceableMetaKey(0);
            // if available read the METAFILEHEADER
            mpInputStream->ReadUInt32( nPlaceableMetaKey );
            if (!mpInputStream->good())
                return false;

            tools::Rectangle aPlaceableBound;

            bool bPlaceable = nPlaceableMetaKey == 0x9ac6cdd7L;

            SAL_INFO("vcl.wmf", "Placeable: \"" << (bPlaceable ? "yes" : "no") << "\"");

            if (bPlaceable)
            {
                //TODO do some real error handling here
                sal_Int16 nVal;

                // Skip reserved bytes
                mpInputStream->SeekRel(2);

                // BoundRect
                mpInputStream->ReadInt16( nVal );
                aPlaceableBound.SetLeft( nVal );
                mpInputStream->ReadInt16( nVal );
                aPlaceableBound.SetTop( nVal );
                mpInputStream->ReadInt16( nVal );
                aPlaceableBound.SetRight( nVal );
                mpInputStream->ReadInt16( nVal );
                aPlaceableBound.SetBottom( nVal );

                // inch
                mpInputStream->ReadUInt16( mnUnitsPerInch );

                // reserved
                mpInputStream->SeekRel( 4 );

                // Skip and don't check the checksum
                mpInputStream->SeekRel( 2 );
            }
            else
            {
                mnUnitsPerInch = 96;

                if (mpExternalHeader != nullptr
                    && mpExternalHeader->xExt > 0
                    && mpExternalHeader->yExt > 0
                    && (mpExternalHeader->mapMode == MM_ISOTROPIC || mpExternalHeader->mapMode == MM_ANISOTROPIC))
                {
                    // #n417818#: If we have an external header then overwrite the bounds!
                    tools::Rectangle aExtRect(0, 0,
                        static_cast<double>(mpExternalHeader->xExt) * 567 * mnUnitsPerInch / 1440000,
                        static_cast<double>(mpExternalHeader->yExt) * 567 * mnUnitsPerInch / 1440000);
                    aPlaceableBound = aExtRect;

                    SAL_INFO("vcl.wmf", "External header size "
                        " t: " << aPlaceableBound.Left() << " l: " << aPlaceableBound.Top()
                        << " b: " << aPlaceableBound.Right() << " r: " << aPlaceableBound.Bottom());

                    SetMapMode(mpExternalHeader->mapMode);
                }
                else
                {
                    mpInputStream->Seek(nStrmPos + 18);    // set the streampos to the start of the metaactions
                    GetPlaceableBound(aPlaceableBound, mpInputStream);

                    // The image size is not known so normalize the calculated bounds so that the
                    // resulting image is not too big
                    const double fMaxWidth = static_cast<double>(aMaxWidth);
                    if (aPlaceableBound.GetWidth() > aMaxWidth)
                    {
                        double fRatio = aPlaceableBound.GetWidth() / fMaxWidth;

                        aPlaceableBound = tools::Rectangle(
                            aPlaceableBound.Left() / fRatio,
                            aPlaceableBound.Top() / fRatio,
                            aPlaceableBound.Right() / fRatio,
                            aPlaceableBound.Bottom() / fRatio);

                        SAL_INFO("vcl.wmf", "Placeable bounds "
                            " t: " << aPlaceableBound.Left() << " l: " << aPlaceableBound.Top()
                            << " b: " << aPlaceableBound.Right() << " r: " << aPlaceableBound.Bottom());
                    }
                }

                mpInputStream->Seek( nStrmPos );
            }

            SetWinOrg( aPlaceableBound.TopLeft() );
            Size aWMFSize( labs( aPlaceableBound.GetWidth() ), labs( aPlaceableBound.GetHeight() ) );
            SetWinExt( aWMFSize );

            SAL_INFO("vcl.wmf", "WMF size  w: " << aWMFSize.Width()    << " h: " << aWMFSize.Height());

            Size aDevExt( 10000, 10000 );
            if( ( labs( aWMFSize.Width() ) > 1 ) && ( labs( aWMFSize.Height() ) > 1 ) )
            {
                const Fraction  aFrac( 1, mnUnitsPerInch);
                MapMode         aWMFMap( MapUnit::MapInch, Point(), aFrac, aFrac );
                Size            aSize100(OutputDevice::LogicToLogic(aWMFSize, aWMFMap, MapMode(MapUnit::Map100thMM)));
                aDevExt = Size( labs( aSize100.Width() ), labs( aSize100.Height() ) );
            }
            SetDevExt( aDevExt );

            SAL_INFO("vcl.wmf", "Dev size  w: " << aDevExt.Width()    << " h: " << aDevExt.Height());

            // read the METAHEADER
            sal_uInt32 nMetaKey(0);
            mpInputStream->ReadUInt32( nMetaKey ); // type and headersize
            if (!mpInputStream->good())
                return false;
            if (nMetaKey != 0x00090001)
            {
                sal_uInt16 aNextWord(0);
                mpInputStream->ReadUInt16( aNextWord );
                if (nMetaKey != 0x10000 || aNextWord != 0x09)
                {
                    mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );
                    return false;
                }
            }

            mpInputStream->SeekRel( 2 ); // Version (of Windows)
            mpInputStream->SeekRel( 4 ); // Size (of file in words)
            mpInputStream->SeekRel( 2 ); // NoObjects (maximum number of simultaneous objects)
            mpInputStream->SeekRel( 4 ); // MaxRecord (size of largest record in words)
            mpInputStream->SeekRel( 2 ); // NoParameters (Unused

            return mpInputStream->good();
        }

        void WmfReader::ReadWMF()
        {
            sal_uInt16  nFunction;

            mnSkipActions = 0;

            mpEMFStream.reset();
            mnEMFRecCount = 0;
            mnEMFRec = 0;
            mnEMFSize = 0;

            SetMapMode( MM_ANISOTROPIC );
            SetWinOrg( Point() );
            SetWinExt( Size( 1, 1 ) );
            SetDevExt( Size( 10000, 10000 ) );

            mnEndPos=mpInputStream->Seek( STREAM_SEEK_TO_END );
            mpInputStream->Seek( mnStartPos );

            if ( ReadHeader( ) )
            {
                auto nPos = mpInputStream->Tell();

                if( mnEndPos - mnStartPos )
                {
                    bool bEMFAvailable = false;
                    while( true )
                    {
                        mpInputStream->ReadUInt32(mnRecSize).ReadUInt16( nFunction );

                        if (
                             !mpInputStream->good() ||
                             (mnRecSize < 3) ||
                             (mnRecSize == 3 && nFunction == 0)
                           )
                        {
                            if( mpInputStream->eof() )
                                mpInputStream->SetError( SVSTREAM_FILEFORMAT_ERROR );

                            break;
                        }

                        const sal_uInt32 nAvailableBytes = mnEndPos - nPos;
                        const sal_uInt32 nMaxPossibleRecordSize = nAvailableBytes/2;
                        if (mnRecSize > nMaxPossibleRecordSize)
                        {
                            mpInputStream->SetError(SVSTREAM_FILEFORMAT_ERROR);
                            break;
                        }

                        if ( !bEMFAvailable )
                        {
                            if(   !maBmpSaveList.empty()
                              && ( nFunction != W_META_STRETCHDIB    )
                              && ( nFunction != W_META_DIBBITBLT     )
                              && ( nFunction != W_META_DIBSTRETCHBLT )
                              )
                            {
                                ResolveBitmapActions( maBmpSaveList );
                            }

                            if ( !mnSkipActions)
                                ReadRecordParams( nFunction );
                            else
                                mnSkipActions--;

                            if(mpEMFStream && mnEMFRecCount == mnEMFRec)
                            {
                                GDIMetaFile aMeta;
                                mpEMFStream->Seek( 0 );
                                std::unique_ptr<EmfReader> pEMFReader(o3tl::make_unique<EmfReader>( *mpEMFStream, aMeta ));
                                bEMFAvailable = pEMFReader->ReadEnhWMF();
                                pEMFReader.reset(); // destroy first!!!

                                if( bEMFAvailable )
                                {
                                    AddFromGDIMetaFile( aMeta );
                                    SetrclFrame( tools::Rectangle( Point(0, 0), aMeta.GetPrefSize()));

                                    // the stream needs to be set to the wmf end position,
                                    // otherwise the GfxLink that is created will be incorrect
                                    // (leading to graphic loss after swapout/swapin).
                                    // so we will proceed normally, but are ignoring further wmf
                                    // records
                                }
                                else
                                {
                                    // something went wrong
                                    // continue with WMF, don't try this again
                                    mpEMFStream.reset();
                                }
                            }
                        }

                        nPos += mnRecSize * 2;
                        mpInputStream->Seek(nPos);
                    }
                }
                else
                    mpInputStream->SetError( SVSTREAM_GENERALERROR );

                if( !mpInputStream->GetError() && !maBmpSaveList.empty() )
                    ResolveBitmapActions( maBmpSaveList );
            }
            if ( mpInputStream->GetError() )
                mpInputStream->Seek( mnStartPos );
        }

        void WmfReader::GetPlaceableBound( tools::Rectangle& rPlaceableBound, SvStream* pStm )
        {
            bool bRet = true;

            tools::Rectangle aBound;
            aBound.SetLeft( RECT_MAX );
            aBound.SetTop( RECT_MAX );
            aBound.SetRight( RECT_MIN );
            aBound.SetBottom( RECT_MIN );
            bool bBoundsDetermined = false;

            auto nPos = pStm->Tell();
            auto nEnd = nPos + pStm->remainingSize();

            Point aWinOrg(0,0);
            boost::optional<Size>  aWinExt;

            Point aViewportOrg(0,0);
            boost::optional<Size>  aViewportExt;

            if (nEnd - nPos)
            {
                sal_Int16 nMapMode = MM_ANISOTROPIC;
                sal_uInt16 nFunction;
                sal_uInt32 nRSize;

                while( bRet )
                {
                    pStm->ReadUInt32( nRSize ).ReadUInt16( nFunction );

                    if( pStm->GetError() )
                    {
                        bRet = false;
                        break;
                    }
                    else if ( nRSize==3 && nFunction==0 )
                    {
                        break;
                    }
                    else if ( nRSize < 3 || pStm->eof() )
                    {
                        pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
                        bRet = false;
                        break;
                    }
                    switch( nFunction )
                    {
                        case W_META_SETWINDOWORG:
                        {
                            aWinOrg = ReadYX();
                        }
                        break;

                        case W_META_SETWINDOWEXT:
                        {
                            sal_Int16 nWidth(0), nHeight(0);
                            pStm->ReadInt16(nHeight);
                            pStm->ReadInt16(nWidth);
                            aWinExt = Size(nWidth, nHeight);
                        }
                        break;

                        case W_META_SETVIEWPORTORG:
                        {
                            aViewportOrg = ReadYX();
                        }
                        break;

                        case W_META_SETVIEWPORTEXT:
                        {
                            sal_Int16 nWidth(0), nHeight(0);
                            pStm->ReadInt16(nHeight);
                            pStm->ReadInt16(nWidth);
                            aViewportExt = Size(nWidth, nHeight);
                        }
                        break;

                        case W_META_SETMAPMODE :
                            pStm->ReadInt16( nMapMode );
                        break;

                        case W_META_MOVETO:
                        case W_META_LINETO:
                            GetWinExtMax( ReadYX(), aBound, nMapMode );
                            bBoundsDetermined = true;
                        break;

                        case W_META_RECTANGLE:
                        case W_META_INTERSECTCLIPRECT:
                        case W_META_EXCLUDECLIPRECT :
                        case W_META_ELLIPSE:
                            GetWinExtMax( ReadRectangle(), aBound, nMapMode );
                            bBoundsDetermined = true;
                        break;

                        case W_META_ROUNDRECT:
                            ReadYXExt(); // size
                            GetWinExtMax( ReadRectangle(), aBound, nMapMode );
                            bBoundsDetermined = true;
                        break;

                        case W_META_ARC:
                        case W_META_PIE:
                        case W_META_CHORD:
                            ReadYX(); // end
                            ReadYX(); // start
                            GetWinExtMax( ReadRectangle(), aBound, nMapMode );
                            bBoundsDetermined = true;
                        break;

                        case W_META_POLYGON:
                        {
                            bool bRecordOk = true;

                            sal_uInt16 nPoints(0);
                            pStm->ReadUInt16( nPoints );

                            if (nPoints > pStm->remainingSize() / (2 * sizeof(sal_uInt16)))
                            {
                                bRecordOk = false;
                            }
                            else
                            {
                                for(sal_uInt16 i = 0; i < nPoints; i++ )
                                {
                                    GetWinExtMax( ReadPoint(), aBound, nMapMode );
                                    bBoundsDetermined = true;
                                }
                            }

                            SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polyline record claimed more points than the stream can provide");

                            if (!bRecordOk)
                            {
                                pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
                                bRet = false;
                                break;
                            }
                        }
                        break;

                        case W_META_POLYPOLYGON:
                        {
                            bool bRecordOk = true;
                            sal_uInt16 nPoly(0), nPoints(0);
                            pStm->ReadUInt16(nPoly);
                            if (nPoly > pStm->remainingSize() / sizeof(sal_uInt16))
                            {
                                bRecordOk = false;
                            }
                            else
                            {
                                for(sal_uInt16 i = 0; i < nPoly; i++ )
                                {
                                    sal_uInt16 nP = 0;
                                    pStm->ReadUInt16( nP );
                                    if (nP > SAL_MAX_UINT16 - nPoints)
                                    {
                                        bRecordOk = false;
                                        break;
                                    }
                                    nPoints += nP;
                                }
                            }

                            SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polypolygon record has more polygons than we can handle");

                            bRecordOk = bRecordOk && pStm->good();

                            if (!bRecordOk)
                            {
                                pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
                                bRet = false;
                                break;
                            }

                            if (nPoints > pStm->remainingSize() / (2 * sizeof(sal_uInt16)))
                            {
                                bRecordOk = false;
                            }
                            else
                            {
                                for (sal_uInt16 i = 0; i < nPoints; i++ )
                                {
                                    GetWinExtMax( ReadPoint(), aBound, nMapMode );
                                    bBoundsDetermined = true;
                                }
                            }

                            SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polypolygon record claimed more points than the stream can provide");

                            bRecordOk &= pStm->good();

                            if (!bRecordOk)
                            {
                                pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
                                bRet = false;
                                break;
                            }
                        }
                        break;

                        case W_META_POLYLINE:
                        {
                            bool bRecordOk = true;

                            sal_uInt16 nPoints(0);
                            pStm->ReadUInt16(nPoints);
                            if (nPoints > pStm->remainingSize() / (2 * sizeof(sal_uInt16)))
                            {
                                bRecordOk = false;
                            }
                            else
                            {
                                for (sal_uInt16 i = 0; i < nPoints; ++i)
                                {
                                    GetWinExtMax( ReadPoint(), aBound, nMapMode );
                                    bBoundsDetermined = true;
                                }
                            }

                            SAL_WARN_IF(!bRecordOk, "vcl.wmf", "polyline record claimed more points than the stream can provide");

                            if (!bRecordOk)
                            {
                                pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
                                bRet = false;
                                break;
                            }
                        }
                        break;

                        case W_META_SETPIXEL:
                        {
                            ReadColor();
                            GetWinExtMax( ReadYX(), aBound, nMapMode );
                            bBoundsDetermined = true;
                        }
                        break;

                        case W_META_TEXTOUT:
                        {
                            sal_uInt16 nLength;
                            pStm->ReadUInt16( nLength );
                            // todo: we also have to take care of the text width
                            if ( nLength )
                            {
                                pStm->SeekRel( ( nLength + 1 ) &~ 1 );
                                GetWinExtMax( ReadYX(), aBound, nMapMode );
                                bBoundsDetermined = true;
                            }
                        }
                        break;

                        case W_META_EXTTEXTOUT:
                        {
                            sal_uInt16  nLen, nOptions;
                            Point       aPosition;

                            aPosition = ReadYX();
                            pStm->ReadUInt16( nLen ).ReadUInt16( nOptions );
                            // todo: we also have to take care of the text width
                            if( nLen )
                            {
                                GetWinExtMax( aPosition, aBound, nMapMode );
                                bBoundsDetermined = true;
                            }
                        }
                        break;
                        case W_META_BITBLT:
                        case W_META_STRETCHBLT:
                        case W_META_DIBBITBLT:
                        case W_META_DIBSTRETCHBLT:
                        case W_META_STRETCHDIB:
                        {
                            sal_Int32   nWinROP;
                            sal_uInt16  nSx, nSy, nUsage;
                            pStm->ReadInt32( nWinROP );

                            if( nFunction == W_META_STRETCHDIB )
                                pStm->ReadUInt16( nUsage );

                            // nSye and nSxe is the number of pixels that has to been used
                            if( nFunction == W_META_STRETCHDIB || nFunction == W_META_STRETCHBLT || nFunction == W_META_DIBSTRETCHBLT )
                            {
                                sal_uInt16 nSxe, nSye;
                                pStm->ReadUInt16( nSye ).ReadUInt16( nSxe );
                            }

                            // nSy and nx is the offset of the first pixel
                            pStm->ReadUInt16( nSy ).ReadUInt16( nSx );

                            if( nFunction == W_META_STRETCHDIB || nFunction == W_META_DIBBITBLT || nFunction == W_META_DIBSTRETCHBLT )
                            {
                                if ( nWinROP == PATCOPY )
                                    pStm->ReadUInt16( nUsage );    // i don't know anything of this parameter, so its called nUsage
                                                        // DrawRect( Rectangle( ReadYX(), aDestSize ), false );

                                Size aDestSize( ReadYXExt() );
                                if ( aDestSize.Width() && aDestSize.Height() )  // #92623# do not try to read buggy bitmaps
                                {
                                    tools::Rectangle aDestRect( ReadYX(), aDestSize );
                                    GetWinExtMax( aDestRect, aBound, nMapMode );
                                    bBoundsDetermined = true;
                                }
                            }
                        }
                        break;

                        case W_META_PATBLT:
                        {
                            sal_uInt32 nROP;
                            pStm->ReadUInt32( nROP );
                            Size aSize = ReadYXExt();
                            GetWinExtMax( tools::Rectangle( ReadYX(), aSize ), aBound, nMapMode );
                            bBoundsDetermined = true;
                        }
                        break;
                    }

                    const auto nAvailableBytes = nEnd - nPos;
                    const auto nMaxPossibleRecordSize = nAvailableBytes/2;
                    if (nRSize <= nMaxPossibleRecordSize)
                    {
                        nPos += nRSize * 2;
                        pStm->Seek(nPos);
                    }
                    else
                    {
                        pStm->SetError( SVSTREAM_FILEFORMAT_ERROR );
                        bRet = false;
                    }
                }
            }
            else
            {
                pStm->SetError( SVSTREAM_GENERALERROR );
                bRet = false;
            }

            if (bRet)
            {
                if (aWinExt)
                {
                    rPlaceableBound = tools::Rectangle(aWinOrg, *aWinExt);
                    SAL_INFO("vcl.wmf", "Window dimension "
                               " t: " << rPlaceableBound.Left()  << " l: " << rPlaceableBound.Top()
                            << " b: " << rPlaceableBound.Right() << " r: " << rPlaceableBound.Bottom());
                }
                else if (aViewportExt)
                {
                    rPlaceableBound = tools::Rectangle(aViewportOrg, *aViewportExt);
                    SAL_INFO("vcl.wmf", "Viewport dimension "
                               " t: " << rPlaceableBound.Left()  << " l: " << rPlaceableBound.Top()
                            << " b: " << rPlaceableBound.Right() << " r: " << rPlaceableBound.Bottom());
                }
                else if (bBoundsDetermined)
                {
                    rPlaceableBound = aBound;
                    SAL_INFO("vcl.wmf", "Determined dimension "
                               " t: " << rPlaceableBound.Left()  << " l: " << rPlaceableBound.Top()
                            << " b: " << rPlaceableBound.Right() << " r: " << rPlaceableBound.Bottom());
                }
                else
                {
                    rPlaceableBound.SetLeft( 0 );
                    rPlaceableBound.SetTop( 0 );
                    rPlaceableBound.SetRight( aMaxWidth );
                    rPlaceableBound.SetBottom( aMaxWidth );
                    SAL_INFO("vcl.wmf", "Default dimension "
                               " t: " << rPlaceableBound.Left()  << " l: " << rPlaceableBound.Top()
                            << " b: " << rPlaceableBound.Right() << " r: " << rPlaceableBound.Bottom());
                }
            }
        }

        WmfReader::WmfReader(SvStream& rStreamWMF, GDIMetaFile& rGDIMetaFile, const WmfExternal* pExternalHeader)
            : MtfTools(rGDIMetaFile, rStreamWMF)
            , mnUnitsPerInch(96)
            , mnRecSize(0)
            , mpEMFStream()
            , mnEMFRecCount(0)
            , mnEMFRec(0)
            , mnEMFSize(0)
            , mnSkipActions(0)
            , mpExternalHeader(pExternalHeader)
        {
        }
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V1023 A pointer without owner is added to the 'maBmpSaveList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.

↑ V1023 A pointer without owner is added to the 'maBmpSaveList' container by the 'emplace_back' method. A memory leak will occur in case of an exception.