SDPR: Overhauled D2DRenderer to use sal::systools::COMReference

All stuff used from MS with names starting with ID2D1* is COM
API stuff, so referenced and interface-based. I thought about
making this more safe since a while (shared/unique_ptr, ...)
but found no good way to do it.
Also did not want to use CComPtr from MS and expand the devenv
we need on win, so was short before doing an own small smartptr
class. Luckily I asked sberg and he pointed me to the already
existing sal::systools::COMReference which exactly does what
I need here - thanks!
Unluckily I now had to change a lot of code - sigh. I wish
I had known earlier :-/
This change contains the renderer completely adapted to using
that much safer and better ressource control.
Plus I added (even more) comments to try to make more clear
in many plasces what's going on, what is done and why.

Change-Id: Ia2aa3223d0e5f7ec6569cde176cec1fadcd921dc
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/145142
Tested-by: Jenkins
Reviewed-by: Armin Le Grand <Armin.Le.Grand@me.com>

1 files changed, 307 insertions, 289 deletions

diff --git a/drawinglayer/source/processor2d/d2dpixelprocessor2d.cxx b/drawinglayer/source/processor2d/d2dpixelprocessor2d.cxx
index 2ed7ea526959..04c6b400039b 100644
--- a/drawinglayer/source/processor2d/d2dpixelprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/d2dpixelprocessor2d.cxx
@@ -56,51 +56,44 @@ using namespace com::sun::star;
 
 namespace
 {
-class ID2D1FactoryProvider
+class ID2D1GlobalFactoryProvider
 {
-    ID2D1Factory* mpD2DFactory;
+    sal::systools::COMReference<ID2D1Factory> mpD2DFactory;
 
 public:
-    ID2D1FactoryProvider()
+    ID2D1GlobalFactoryProvider()
         : mpD2DFactory(nullptr)
     {
-        HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory),
-                                       nullptr, reinterpret_cast<void**>(&mpD2DFactory));
+        const HRESULT hr(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED,
+                                           __uuidof(ID2D1Factory), nullptr,
+                                           reinterpret_cast<void**>(&mpD2DFactory)));
 
         if (!SUCCEEDED(hr))
-            mpD2DFactory = nullptr;
+            mpD2DFactory.clear();
     }
 
-    ~ID2D1FactoryProvider()
-    {
-        if (mpD2DFactory)
-            mpD2DFactory->Release();
-    }
+    ~ID2D1GlobalFactoryProvider() {}
 
-    ID2D1Factory* getID2D1Factory() const { return mpD2DFactory; }
+    sal::systools::COMReference<ID2D1Factory>& getID2D1Factory() { return mpD2DFactory; }
 };
 
-ID2D1FactoryProvider aID2D1FactoryProvider;
+ID2D1GlobalFactoryProvider aID2D1GlobalFactoryProvider;
 
 class ID2D1GlobalRenderTargetProvider
 {
-    ID2D1DCRenderTarget* mpID2D1DCRenderTarget;
+    sal::systools::COMReference<ID2D1DCRenderTarget> mpID2D1DCRenderTarget;
 
 public:
     ID2D1GlobalRenderTargetProvider()
-        : mpID2D1DCRenderTarget(nullptr)
+        : mpID2D1DCRenderTarget()
     {
     }
 
-    ~ID2D1GlobalRenderTargetProvider()
-    {
-        if (mpID2D1DCRenderTarget)
-            mpID2D1DCRenderTarget->Release();
-    }
+    ~ID2D1GlobalRenderTargetProvider() {}
 
-    ID2D1DCRenderTarget* getID2D1DCRenderTarget() const
+    sal::systools::COMReference<ID2D1DCRenderTarget>& getID2D1DCRenderTarget()
     {
-        if (nullptr == mpID2D1DCRenderTarget && aID2D1FactoryProvider.getID2D1Factory())
+        if (!mpID2D1DCRenderTarget && aID2D1GlobalFactoryProvider.getID2D1Factory())
         {
             const D2D1_RENDER_TARGET_PROPERTIES aRTProps(D2D1::RenderTargetProperties(
                 D2D1_RENDER_TARGET_TYPE_DEFAULT,
@@ -108,9 +101,8 @@ public:
                                   D2D1_ALPHA_MODE_IGNORE), //D2D1_ALPHA_MODE_PREMULTIPLIED),
                 0, 0, D2D1_RENDER_TARGET_USAGE_NONE, D2D1_FEATURE_LEVEL_DEFAULT));
 
-            const HRESULT hr(aID2D1FactoryProvider.getID2D1Factory()->CreateDCRenderTarget(
-                &aRTProps,
-                &(const_cast<ID2D1GlobalRenderTargetProvider*>(this)->mpID2D1DCRenderTarget)));
+            const HRESULT hr(aID2D1GlobalFactoryProvider.getID2D1Factory()->CreateDCRenderTarget(
+                &aRTProps, &mpID2D1DCRenderTarget));
 
             // interestingly this ID2D1DCRenderTarget already works and can hold
             // created ID2D1Bitmap(s) in RenderTarget-specific form, *without*
@@ -119,7 +111,7 @@ public:
             // to have a HDC that is valid during LO's lifetime.
 
             if (!SUCCEEDED(hr))
-                const_cast<ID2D1GlobalRenderTargetProvider*>(this)->mpID2D1DCRenderTarget = nullptr;
+                mpID2D1DCRenderTarget.clear();
         }
 
         return mpID2D1DCRenderTarget;
@@ -131,24 +123,20 @@ ID2D1GlobalRenderTargetProvider aID2D1GlobalRenderTargetProvider;
 class SystemDependentData_ID2D1PathGeometry : public basegfx::SystemDependentData
 {
 private:
-    ID2D1PathGeometry* mpID2D1PathGeometry;
+    sal::systools::COMReference<ID2D1PathGeometry> mpID2D1PathGeometry;
 
 public:
-    SystemDependentData_ID2D1PathGeometry(ID2D1PathGeometry* pID2D1PathGeometry)
+    SystemDependentData_ID2D1PathGeometry(
+        sal::systools::COMReference<ID2D1PathGeometry>& rID2D1PathGeometry)
         : basegfx::SystemDependentData(Application::GetSystemDependentDataManager())
-        , mpID2D1PathGeometry(pID2D1PathGeometry)
+        , mpID2D1PathGeometry(rID2D1PathGeometry)
     {
     }
 
-    ~SystemDependentData_ID2D1PathGeometry()
+    const sal::systools::COMReference<ID2D1PathGeometry>& getID2D1PathGeometry() const
     {
-        if (nullptr != getID2D1PathGeometry())
-        {
-            mpID2D1PathGeometry->Release();
-        }
+        return mpID2D1PathGeometry;
     }
-
-    ID2D1PathGeometry* getID2D1PathGeometry() const { return mpID2D1PathGeometry; }
     virtual sal_Int64 estimateUsageInBytes() const override;
 };
 
@@ -156,10 +144,10 @@ sal_Int64 SystemDependentData_ID2D1PathGeometry::estimateUsageInBytes() const
 {
     sal_Int64 aRetval(0);
 
-    if (nullptr != getID2D1PathGeometry())
+    if (getID2D1PathGeometry())
     {
         UINT32 nCount(0);
-        HRESULT hr = getID2D1PathGeometry()->GetSegmentCount(&nCount);
+        const HRESULT hr(getID2D1PathGeometry()->GetSegmentCount(&nCount));
 
         if (SUCCEEDED(hr))
         {
@@ -212,7 +200,8 @@ basegfx::B2DPoint impPixelSnap(const basegfx::B2DPolygon& rPolygon,
     return rPolygon.getB2DPoint(nIndex);
 }
 
-void addB2DPolygonToPathGeometry(ID2D1GeometrySink* pSink, const basegfx::B2DPolygon& rPolygon,
+void addB2DPolygonToPathGeometry(sal::systools::COMReference<ID2D1GeometrySink>& rSink,
+                                 const basegfx::B2DPolygon& rPolygon,
                                  const drawinglayer::geometry::ViewInformation2D* pViewInformation)
 {
     const sal_uInt32 nPointCount(rPolygon.count());
@@ -230,7 +219,7 @@ void addB2DPolygonToPathGeometry(ID2D1GeometrySink* pSink, const basegfx::B2DPol
 
         if (aEdge.isBezier())
         {
-            pSink->AddBezier(
+            rSink->AddBezier(
                 D2D1::BezierSegment(D2D1::Point2F(aEdge.getControlPointA().getX(),
                                                   aEdge.getControlPointA().getY()), //C1
                                     D2D1::Point2F(aEdge.getControlPointB().getX(),
@@ -239,7 +228,7 @@ void addB2DPolygonToPathGeometry(ID2D1GeometrySink* pSink, const basegfx::B2DPol
         }
         else
         {
-            pSink->AddLine(D2D1::Point2F(aEndPoint.getX(), aEndPoint.getY()));
+            rSink->AddLine(D2D1::Point2F(aEndPoint.getX(), aEndPoint.getY()));
         }
     }
 }
@@ -266,16 +255,17 @@ getOrCreatePathGeometry(const basegfx::B2DPolygon& rPolygon,
         }
     }
 
-    ID2D1PathGeometry* pID2D1PathGeometry(nullptr);
-    HRESULT hr = aID2D1FactoryProvider.getID2D1Factory()->CreatePathGeometry(&pID2D1PathGeometry);
+    sal::systools::COMReference<ID2D1PathGeometry> pID2D1PathGeometry;
+    HRESULT hr(
+        aID2D1GlobalFactoryProvider.getID2D1Factory()->CreatePathGeometry(&pID2D1PathGeometry));
     const sal_uInt32 nPointCount(rPolygon.count());
 
     if (SUCCEEDED(hr) && nPointCount)
     {
-        ID2D1GeometrySink* pSink = nullptr;
+        sal::systools::COMReference<ID2D1GeometrySink> pSink;
         hr = pID2D1PathGeometry->Open(&pSink);
 
-        if (SUCCEEDED(hr))
+        if (SUCCEEDED(hr) && pSink)
         {
             const basegfx::B2DPoint aStart(rViewInformation.getPixelSnapHairline()
                                                ? rPolygon.getB2DPoint(0)
@@ -286,12 +276,11 @@ getOrCreatePathGeometry(const basegfx::B2DPolygon& rPolygon,
             addB2DPolygonToPathGeometry(pSink, rPolygon, &rViewInformation);
             pSink->EndFigure(rPolygon.isClosed() ? D2D1_FIGURE_END_CLOSED : D2D1_FIGURE_END_OPEN);
             pSink->Close();
-            pSink->Release();
         }
     }
 
     // add to buffering mechanism
-    if (nullptr != pID2D1PathGeometry)
+    if (pID2D1PathGeometry)
     {
         if (rViewInformation.getPixelSnapHairline() || nPointCount <= 4)
         {
@@ -321,16 +310,17 @@ getOrCreateFillGeometry(const basegfx::B2DPolyPolygon& rPolyPolygon)
         return pSystemDependentData_ID2D1PathGeometry;
     }
 
-    ID2D1PathGeometry* pID2D1PathGeometry(nullptr);
-    HRESULT hr = aID2D1FactoryProvider.getID2D1Factory()->CreatePathGeometry(&pID2D1PathGeometry);
+    sal::systools::COMReference<ID2D1PathGeometry> pID2D1PathGeometry;
+    HRESULT hr(
+        aID2D1GlobalFactoryProvider.getID2D1Factory()->CreatePathGeometry(&pID2D1PathGeometry));
     const sal_uInt32 nCount(rPolyPolygon.count());
 
     if (SUCCEEDED(hr) && nCount)
     {
-        ID2D1GeometrySink* pSink = nullptr;
+        sal::systools::COMReference<ID2D1GeometrySink> pSink;
         hr = pID2D1PathGeometry->Open(&pSink);
 
-        if (SUCCEEDED(hr))
+        if (SUCCEEDED(hr) && pSink)
         {
             for (sal_uInt32 a(0); a < nCount; a++)
             {
@@ -349,12 +339,11 @@ getOrCreateFillGeometry(const basegfx::B2DPolyPolygon& rPolyPolygon)
             }
 
             pSink->Close();
-            pSink->Release();
         }
     }
 
     // add to buffering mechanism
-    if (nullptr != pID2D1PathGeometry)
+    if (pID2D1PathGeometry)
     {
         return rPolyPolygon.addOrReplaceSystemDependentData<SystemDependentData_ID2D1PathGeometry>(
             pID2D1PathGeometry);
@@ -366,27 +355,21 @@ getOrCreateFillGeometry(const basegfx::B2DPolyPolygon& rPolyPolygon)
 class SystemDependentData_ID2D1Bitmap : public basegfx::SystemDependentData
 {
 private:
-    ID2D1Bitmap* mpD2DBitmap;
+    sal::systools::COMReference<ID2D1Bitmap> mpD2DBitmap;
     const std::shared_ptr<SalBitmap> maAssociatedAlpha;
 
 public:
-    SystemDependentData_ID2D1Bitmap(ID2D1Bitmap* pD2DBitmap,
+    SystemDependentData_ID2D1Bitmap(sal::systools::COMReference<ID2D1Bitmap>& rD2DBitmap,
                                     const std::shared_ptr<SalBitmap>& rAssociatedAlpha)
         : basegfx::SystemDependentData(Application::GetSystemDependentDataManager())
-        , mpD2DBitmap(pD2DBitmap)
+        , mpD2DBitmap(rD2DBitmap)
         , maAssociatedAlpha(rAssociatedAlpha)
     {
     }
 
-    ~SystemDependentData_ID2D1Bitmap()
-    {
-        if (nullptr != getID2D1Bitmap())
-        {
-            mpD2DBitmap->Release();
-        }
-    }
+    ~SystemDependentData_ID2D1Bitmap() {}
 
-    ID2D1Bitmap* getID2D1Bitmap() const { return mpD2DBitmap; }
+    const sal::systools::COMReference<ID2D1Bitmap>& getID2D1Bitmap() const { return mpD2DBitmap; }
     const std::shared_ptr<SalBitmap>& getAssociatedAlpha() const { return maAssociatedAlpha; }
 
     virtual sal_Int64 estimateUsageInBytes() const override;
@@ -396,8 +379,9 @@ sal_Int64 SystemDependentData_ID2D1Bitmap::estimateUsageInBytes() const
 {
     sal_Int64 aRetval(0);
 
-    if (nullptr != getID2D1Bitmap())
+    if (getID2D1Bitmap())
     {
+        // use factor 4 for RGBA_8 as estimation
         const D2D1_SIZE_U aSizePixel(getID2D1Bitmap()->GetPixelSize());
         aRetval = static_cast<sal_Int64>(aSizePixel.width)
                   * static_cast<sal_Int64>(aSizePixel.height) * 4;
@@ -406,7 +390,7 @@ sal_Int64 SystemDependentData_ID2D1Bitmap::estimateUsageInBytes() const
     return aRetval;
 }
 
-ID2D1Bitmap* createB2DBitmap(const BitmapEx& rBitmapEx)
+sal::systools::COMReference<ID2D1Bitmap> createB2DBitmap(const BitmapEx& rBitmapEx)
 {
     const Size& rSizePixel(rBitmapEx.GetSizePixel());
     const bool bAlpha(rBitmapEx.IsAlpha());
@@ -453,35 +437,34 @@ ID2D1Bitmap* createB2DBitmap(const BitmapEx& rBitmapEx)
         }
     }
 
-    // use GlobalRenderTraget to allow usage combined with
+    // use GlobalRenderTarget to allow usage combined with
     // the Direct2D CreateSharedBitmap-mechanism. This is needed
     // since ID2D1Bitmap is a ID2D1RenderTarget-dependent resource
     // and thus - in principle - would have to be re-created for
     // *each* new ID2D1RenderTarget, that means for *each* new
     // target HDC, resp. OutputDevice
-    ID2D1DCRenderTarget* pGlobalRenderTraget(
-        aID2D1GlobalRenderTargetProvider.getID2D1DCRenderTarget());
-    ID2D1Bitmap* pID2D1Bitmap(nullptr);
+    sal::systools::COMReference<ID2D1Bitmap> pID2D1Bitmap;
 
-    if (nullptr != pGlobalRenderTraget)
+    if (aID2D1GlobalRenderTargetProvider.getID2D1DCRenderTarget())
     {
-        HRESULT hr = pGlobalRenderTraget->CreateBitmap(
+        const HRESULT hr(aID2D1GlobalRenderTargetProvider.getID2D1DCRenderTarget()->CreateBitmap(
             D2D1::SizeU(rSizePixel.Width(), rSizePixel.Height()), &aData[0],
             rSizePixel.Width() * sizeof(sal_uInt32),
             D2D1::BitmapProperties(
                 D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, // DXGI_FORMAT
                                   bAlpha ? D2D1_ALPHA_MODE_PREMULTIPLIED
                                          : D2D1_ALPHA_MODE_IGNORE)), // D2D1_ALPHA_MODE
-            &pID2D1Bitmap);
+            &pID2D1Bitmap));
 
         if (!SUCCEEDED(hr))
-            return nullptr;
+            pID2D1Bitmap.clear();
     }
 
     return pID2D1Bitmap;
 }
 
-ID2D1Bitmap* getOrCreateB2DBitmap(ID2D1RenderTarget& rRT, const BitmapEx& rBitmapEx)
+sal::systools::COMReference<ID2D1Bitmap>
+getOrCreateB2DBitmap(sal::systools::COMReference<ID2D1RenderTarget>& rRT, const BitmapEx& rBitmapEx)
 {
     const basegfx::SystemDependentDataHolder* pHolder(
         rBitmapEx.GetBitmap().accessSystemDependentDataHolder());
@@ -508,9 +491,9 @@ ID2D1Bitmap* getOrCreateB2DBitmap(ID2D1RenderTarget& rRT, const BitmapEx& rBitma
     if (!pSystemDependentData_ID2D1Bitmap)
     {
         // have to create newly
-        ID2D1Bitmap* pID2D1Bitmap(createB2DBitmap(rBitmapEx));
+        sal::systools::COMReference<ID2D1Bitmap> pID2D1Bitmap(createB2DBitmap(rBitmapEx));
 
-        if (nullptr != pID2D1Bitmap)
+        if (pID2D1Bitmap)
         {
             // creation worked, create SystemDependentData_ID2D1Bitmap
             pSystemDependentData_ID2D1Bitmap = std::make_shared<SystemDependentData_ID2D1Bitmap>(
@@ -527,21 +510,22 @@ ID2D1Bitmap* getOrCreateB2DBitmap(ID2D1RenderTarget& rRT, const BitmapEx& rBitma
         }
     }
 
+    sal::systools::COMReference<ID2D1Bitmap> pWrappedD2DBitmap;
+
     if (pSystemDependentData_ID2D1Bitmap)
     {
         // embed to CreateSharedBitmap, that makes it usable on
         // the specified RenderTarget
-        ID2D1Bitmap* pWrappedD2DBitmap(nullptr);
-        HRESULT hr(rRT.CreateSharedBitmap(
+        const HRESULT hr(rRT->CreateSharedBitmap(
             __uuidof(ID2D1Bitmap),
             static_cast<void*>(pSystemDependentData_ID2D1Bitmap->getID2D1Bitmap()), nullptr,
             &pWrappedD2DBitmap));
 
-        if (SUCCEEDED(hr))
-            return pWrappedD2DBitmap;
+        if (!SUCCEEDED(hr))
+            pWrappedD2DBitmap.clear();
     }
 
-    return nullptr;
+    return pWrappedD2DBitmap;
 }
 
 // This is a simple local derivation of D2DPixelProcessor2D to be used
@@ -551,21 +535,19 @@ ID2D1Bitmap* getOrCreateB2DBitmap(ID2D1RenderTarget& rRT, const BitmapEx& rBitma
 // (you need to call process() with the primitives to be painted of
 // course). Then use the local helper getID2D1Bitmap() to access the
 // ID2D1Bitmap which was the target of that operation.
-// The class does not need to call mpBitmapRenderTarget->Release() since
-// mpRT of parent is set to it and that calls Release() already in its
-// destructor, so no destructor needed here.
 class D2DBitmapPixelProcessor2D final : public drawinglayer::processor2d::D2DPixelProcessor2D
 {
     // the local ID2D1BitmapRenderTarget
-    ID2D1BitmapRenderTarget* mpBitmapRenderTarget;
+    sal::systools::COMReference<ID2D1BitmapRenderTarget> mpBitmapRenderTarget;
 
 public:
     // helper class to create another instance of D2DPixelProcessor2D for
     // creating helper-ID2D1Bitmap's for a given ID2D1RenderTarget
     D2DBitmapPixelProcessor2D(const drawinglayer::geometry::ViewInformation2D& rViewInformation,
-                              sal_uInt32 nWidth, sal_uInt32 nHeight, ID2D1RenderTarget& rParent)
+                              sal_uInt32 nWidth, sal_uInt32 nHeight,
+                              sal::systools::COMReference<ID2D1RenderTarget>& rParent)
         : drawinglayer::processor2d::D2DPixelProcessor2D(rViewInformation)
-        , mpBitmapRenderTarget(nullptr)
+        , mpBitmapRenderTarget()
     {
         if (0 == nWidth || 0 == nHeight)
         {
@@ -577,7 +559,7 @@ public:
         {
             // Allocate compatible RGBA render target
             const D2D1_SIZE_U aRenderTargetSizePixel(D2D1::SizeU(nWidth, nHeight));
-            HRESULT hr(rParent.CreateCompatibleRenderTarget(
+            const HRESULT hr(rParent->CreateCompatibleRenderTarget(
                 nullptr, &aRenderTargetSizePixel, nullptr,
                 D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &mpBitmapRenderTarget));
 
@@ -588,30 +570,33 @@ public:
             }
             else
             {
-                setRenderTarget(mpBitmapRenderTarget);
+                sal::systools::COMReference<ID2D1RenderTarget> pRT;
+                mpBitmapRenderTarget->QueryInterface(__uuidof(ID2D1RenderTarget),
+                                                     reinterpret_cast<void**>(&pRT));
+                setRenderTarget(pRT);
             }
         }
 
         if (hasRenderTarget())
         {
             // clear as render preparation
-            getRenderTarget().BeginDraw();
-            getRenderTarget().Clear(D2D1::ColorF(0.0f, 0.0f, 0.0f, 0.0f));
-            getRenderTarget().EndDraw();
+            getRenderTarget()->BeginDraw();
+            getRenderTarget()->Clear(D2D1::ColorF(0.0f, 0.0f, 0.0f, 0.0f));
+            getRenderTarget()->EndDraw();
         }
     }
 
-    ID2D1Bitmap* getID2D1Bitmap() const
+    sal::systools::COMReference<ID2D1Bitmap> getID2D1Bitmap() const
     {
+        sal::systools::COMReference<ID2D1Bitmap> pResult;
+
         // access the resulting bitmap if exists
-        if (nullptr != mpBitmapRenderTarget)
+        if (mpBitmapRenderTarget)
         {
-            ID2D1Bitmap* pInBetweenResult(nullptr);
-            mpBitmapRenderTarget->GetBitmap(&pInBetweenResult);
-            return pInBetweenResult;
+            mpBitmapRenderTarget->GetBitmap(&pResult);
         }
 
-        return nullptr;
+        return pResult;
     }
 };
 }
@@ -621,7 +606,7 @@ namespace drawinglayer::processor2d
 D2DPixelProcessor2D::D2DPixelProcessor2D(const geometry::ViewInformation2D& rViewInformation)
     : BaseProcessor2D(rViewInformation)
     , maBColorModifierStack()
-    , mpRT(nullptr)
+    , mpRT()
     , mnRecursionCounter(0)
     , mnErrorCounter(0)
 {
@@ -631,11 +616,11 @@ D2DPixelProcessor2D::D2DPixelProcessor2D(const geometry::ViewInformation2D& rVie
                                          HDC aHdc)
     : BaseProcessor2D(rViewInformation)
     , maBColorModifierStack()
-    , mpRT(nullptr)
+    , mpRT()
     , mnRecursionCounter(0)
     , mnErrorCounter(0)
 {
-    ID2D1DCRenderTarget* pDCRT = nullptr;
+    sal::systools::COMReference<ID2D1DCRenderTarget> pDCRT;
     tools::Long aOutWidth(0), aOutHeight(0);
 
     if (aHdc)
@@ -644,7 +629,7 @@ D2DPixelProcessor2D::D2DPixelProcessor2D(const geometry::ViewInformation2D& rVie
         aOutHeight = GetDeviceCaps(aHdc, VERTRES);
     }
 
-    if (aOutWidth > 0 && aOutHeight > 0 && aID2D1FactoryProvider.getID2D1Factory())
+    if (aOutWidth > 0 && aOutHeight > 0 && aID2D1GlobalFactoryProvider.getID2D1Factory())
     {
         const D2D1_RENDER_TARGET_PROPERTIES aRTProps(D2D1::RenderTargetProperties(
             D2D1_RENDER_TARGET_TYPE_DEFAULT,
@@ -653,12 +638,10 @@ D2DPixelProcessor2D::D2DPixelProcessor2D(const geometry::ViewInformation2D& rVie
             0, 0, D2D1_RENDER_TARGET_USAGE_NONE, D2D1_FEATURE_LEVEL_DEFAULT));
 
         const HRESULT hr(
-            aID2D1FactoryProvider.getID2D1Factory()->CreateDCRenderTarget(&aRTProps, &pDCRT));
+            aID2D1GlobalFactoryProvider.getID2D1Factory()->CreateDCRenderTarget(&aRTProps, &pDCRT));
 
         if (!SUCCEEDED(hr))
-        {
-            pDCRT = nullptr;
-        }
+            pDCRT.clear();
     }
 
     if (pDCRT)
@@ -668,10 +651,7 @@ D2DPixelProcessor2D::D2DPixelProcessor2D(const geometry::ViewInformation2D& rVie
         const HRESULT hr(pDCRT->BindDC(aHdc, &rc));
 
         if (!SUCCEEDED(hr))
-        {
-            pDCRT->Release();
-            pDCRT = nullptr;
-        }
+            pDCRT.clear();
     }
 
     if (pDCRT)
@@ -701,7 +681,9 @@ D2DPixelProcessor2D::D2DPixelProcessor2D(const geometry::ViewInformation2D& rVie
 
     if (pDCRT)
     {
-        setRenderTarget(pDCRT);
+        sal::systools::COMReference<ID2D1RenderTarget> pRT;
+        pDCRT->QueryInterface(__uuidof(ID2D1RenderTarget), reinterpret_cast<void**>(&pRT));
+        setRenderTarget(pRT);
     }
     else
     {
@@ -709,19 +691,16 @@ D2DPixelProcessor2D::D2DPixelProcessor2D(const geometry::ViewInformation2D& rVie
     }
 }
 
-D2DPixelProcessor2D::~D2DPixelProcessor2D()
-{
-    if (hasRenderTarget())
-        getRenderTarget().Release();
-}
-
 void D2DPixelProcessor2D::processPolygonHairlinePrimitive2D(
     const primitive2d::PolygonHairlinePrimitive2D& rPolygonHairlinePrimitive2D)
 {
     const basegfx::B2DPolygon& rPolygon(rPolygonHairlinePrimitive2D.getB2DPolygon());
 
     if (!rPolygon.count())
+    {
+        // no geometry, done
         return;
+    }
 
     bool bDone(false);
     std::shared_ptr<SystemDependentData_ID2D1PathGeometry> pSystemDependentData_ID2D1PathGeometry(
@@ -729,41 +708,38 @@ void D2DPixelProcessor2D::processPolygonHairlinePrimitive2D(
 
     if (pSystemDependentData_ID2D1PathGeometry)
     {
-        ID2D1TransformedGeometry* pTransformedGeometry = nullptr;
+        sal::systools::COMReference<ID2D1TransformedGeometry> pTransformedGeometry;
         const double fAAOffset(getViewInformation2D().getUseAntiAliasing() ? 0.5 : 0.0);
         const basegfx::B2DHomMatrix& rObjectToView(
             getViewInformation2D().getObjectToViewTransformation());
-        HRESULT hr = aID2D1FactoryProvider.getID2D1Factory()->CreateTransformedGeometry(
+        HRESULT hr(aID2D1GlobalFactoryProvider.getID2D1Factory()->CreateTransformedGeometry(
             pSystemDependentData_ID2D1PathGeometry->getID2D1PathGeometry(),
             D2D1::Matrix3x2F(rObjectToView.a(), rObjectToView.b(), rObjectToView.c(),
                              rObjectToView.d(), rObjectToView.e() + fAAOffset,
                              rObjectToView.f() + fAAOffset),
-            &pTransformedGeometry);
+            &pTransformedGeometry));
 
-        if (SUCCEEDED(hr))
+        if (SUCCEEDED(hr) && pTransformedGeometry)
         {
             const basegfx::BColor aHairlineColor(
                 maBColorModifierStack.getModifiedColor(rPolygonHairlinePrimitive2D.getBColor()));
             const D2D1::ColorF aD2DColor(aHairlineColor.getRed(), aHairlineColor.getGreen(),
                                          aHairlineColor.getBlue());
-            ID2D1SolidColorBrush* pColorBrush(nullptr);
-            hr = getRenderTarget().CreateSolidColorBrush(aD2DColor, &pColorBrush);
+            sal::systools::COMReference<ID2D1SolidColorBrush> pColorBrush;
+            hr = getRenderTarget()->CreateSolidColorBrush(aD2DColor, &pColorBrush);
 
-            if (SUCCEEDED(hr))
+            if (SUCCEEDED(hr) && pColorBrush)
             {
-                getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
+                getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
                 // TODO: Unfortunately Direct2D paint of one pixel wide lines does not
                 // correctly and completely blend 100% over the background. Experimenting
                 // shows that a value around/slightly below 2.0 is needed which hints that
                 // alpha blending the half-shifted lines (see fAAOffset above) is involved.
                 // To get correct blending I try to use just wider hairlines for now. This
                 // may need to be improved - or balanced (trying sqrt(2) now...)
-                getRenderTarget().DrawGeometry(pTransformedGeometry, pColorBrush, 1.44f);
+                getRenderTarget()->DrawGeometry(pTransformedGeometry, pColorBrush, 1.44f);
                 bDone = true;
-                pColorBrush->Release();
             }
-
-            pTransformedGeometry->Release();
         }
     }
 
@@ -778,7 +754,10 @@ void D2DPixelProcessor2D::processPolyPolygonColorPrimitive2D(
     const sal_uInt32 nCount(rPolyPolygon.count());
 
     if (!nCount)
+    {
+        // no geometry, done
         return;
+    }
 
     bool bDone(false);
     std::shared_ptr<SystemDependentData_ID2D1PathGeometry> pSystemDependentData_ID2D1PathGeometry(
@@ -786,36 +765,33 @@ void D2DPixelProcessor2D::processPolyPolygonColorPrimitive2D(
 
     if (pSystemDependentData_ID2D1PathGeometry)
     {
-        ID2D1TransformedGeometry* pTransformedGeometry = nullptr;
+        sal::systools::COMReference<ID2D1TransformedGeometry> pTransformedGeometry;
         const double fAAOffset(getViewInformation2D().getUseAntiAliasing() ? 0.5 : 0.0);
         const basegfx::B2DHomMatrix& rObjectToView(
             getViewInformation2D().getObjectToViewTransformation());
-        HRESULT hr = aID2D1FactoryProvider.getID2D1Factory()->CreateTransformedGeometry(
+        HRESULT hr(aID2D1GlobalFactoryProvider.getID2D1Factory()->CreateTransformedGeometry(
             pSystemDependentData_ID2D1PathGeometry->getID2D1PathGeometry(),
             D2D1::Matrix3x2F(rObjectToView.a(), rObjectToView.b(), rObjectToView.c(),
                              rObjectToView.d(), rObjectToView.e() + fAAOffset,
                              rObjectToView.f() + fAAOffset),
-            &pTransformedGeometry);
+            &pTransformedGeometry));
 
-        if (SUCCEEDED(hr))
+        if (SUCCEEDED(hr) && pTransformedGeometry)
         {
             const basegfx::BColor aFillColor(
                 maBColorModifierStack.getModifiedColor(rPolyPolygonColorPrimitive2D.getBColor()));
             const D2D1::ColorF aD2DColor(aFillColor.getRed(), aFillColor.getGreen(),
                                          aFillColor.getBlue());
 
-            ID2D1SolidColorBrush* pColorBrush(nullptr);
-            hr = getRenderTarget().CreateSolidColorBrush(aD2DColor, &pColorBrush);
+            sal::systools::COMReference<ID2D1SolidColorBrush> pColorBrush;
+            hr = getRenderTarget()->CreateSolidColorBrush(aD2DColor, &pColorBrush);
 
-            if (SUCCEEDED(hr))
+            if (SUCCEEDED(hr) && pColorBrush)
             {
-                getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
-                getRenderTarget().FillGeometry(pTransformedGeometry, pColorBrush);
+                getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
+                getRenderTarget()->FillGeometry(pTransformedGeometry, pColorBrush);
                 bDone = true;
-                pColorBrush->Release();
             }
-
-            pTransformedGeometry->Release();
         }
     }
 
@@ -839,7 +815,7 @@ void D2DPixelProcessor2D::processBitmapPrimitive2D(
 
         if (!aUnitRange.overlaps(rDiscreteViewPort))
         {
-            // content is outside discrete local ViewPort
+            // content is outside discrete local ViewPort, done
             return;
         }
     }
@@ -848,16 +824,18 @@ void D2DPixelProcessor2D::processBitmapPrimitive2D(
 
     if (aBitmapEx.IsEmpty() || aBitmapEx.GetSizePixel().IsEmpty())
     {
+        // no pixel data, done
         return;
     }
 
     if (maBColorModifierStack.count())
     {
+        // need to apply ColorModifier to Bitmap data
         aBitmapEx = aBitmapEx.ModifyBitmapEx(maBColorModifierStack);
 
         if (aBitmapEx.IsEmpty())
         {
-            // color gets completely replaced, get it
+            // color gets completely replaced, get it (any input works)
             const basegfx::BColor aModifiedColor(
                 maBColorModifierStack.getModifiedColor(basegfx::BColor()));
 
@@ -870,24 +848,25 @@ void D2DPixelProcessor2D::processBitmapPrimitive2D(
                 new primitive2d::PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aPolygon),
                                                              aModifiedColor));
 
+            // draw as Polygon, done
             processPolyPolygonColorPrimitive2D(*aTemp);
             return;
         }
     }
 
     bool bDone(false);
-    ID2D1Bitmap* pD2DBitmap(getOrCreateB2DBitmap(getRenderTarget(), aBitmapEx));
+    sal::systools::COMReference<ID2D1Bitmap> pD2DBitmap(
+        getOrCreateB2DBitmap(getRenderTarget(), aBitmapEx));
 
-    if (nullptr != pD2DBitmap)
+    if (pD2DBitmap)
     {
         const double fAAOffset(getViewInformation2D().getUseAntiAliasing() ? 0.5 : 0.0);
-        getRenderTarget().SetTransform(D2D1::Matrix3x2F(
+        getRenderTarget()->SetTransform(D2D1::Matrix3x2F(
             aLocalTransform.a(), aLocalTransform.b(), aLocalTransform.c(), aLocalTransform.d(),
             aLocalTransform.e() + fAAOffset, aLocalTransform.f() + fAAOffset));
 
         // destinationRectangle is part of transformation above, so use UnitRange
-        getRenderTarget().DrawBitmap(pD2DBitmap, D2D1::RectF(0.0, 0.0, 1.0, 1.0));
-        pD2DBitmap->Release();
+        getRenderTarget()->DrawBitmap(pD2DBitmap, D2D1::RectF(0.0, 0.0, 1.0, 1.0));
         bDone = true;
     }
 
@@ -895,27 +874,28 @@ void D2DPixelProcessor2D::processBitmapPrimitive2D(
         increaseError();
 }
 
-ID2D1Bitmap* D2DPixelProcessor2D::implCreateAlpha_Direct(
+sal::systools::COMReference<ID2D1Bitmap> D2DPixelProcessor2D::implCreateAlpha_Direct(
     const primitive2d::TransparencePrimitive2D& rTransCandidate,
     const basegfx::B2DRange& rVisibleRange)
 {
     // Try if we can use ID2D1DeviceContext/d2d1_1 by querying for interface.
     // Only then can we use ID2D1Effect/CLSID_D2D1LuminanceToAlpha and it makes
     // sense to try to do it this way in this implementation
-    ID2D1DeviceContext* pID2D1DeviceContext(nullptr);
-    getRenderTarget().QueryInterface(__uuidof(ID2D1DeviceContext),
-                                     reinterpret_cast<void**>(&pID2D1DeviceContext));
+    sal::systools::COMReference<ID2D1DeviceContext> pID2D1DeviceContext;
+    getRenderTarget()->QueryInterface(__uuidof(ID2D1DeviceContext),
+                                      reinterpret_cast<void**>(&pID2D1DeviceContext));
+    sal::systools::COMReference<ID2D1Bitmap> pRetval;
 
-    if (nullptr == pID2D1DeviceContext)
+    if (!pID2D1DeviceContext)
     {
-        // no, done - use fallback by returning empty - we have not the preconditions for this
-        return nullptr;
+        // no, done - tell caller to use fallback by returning empty - we have
+        // not the preconditions for this
+        return pRetval;
     }
 
     // Release early, was only a test and I saw comments in docu thatQueryInterface
     // does already increase that refcount
-    pID2D1DeviceContext->Release();
-    pID2D1DeviceContext = nullptr;
+    pID2D1DeviceContext.clear();
 
     // I had a former version (call it 'a') where I directly painted to a
     // alpha-only bitmap target, see aAlphaFormat below and refer to
@@ -972,15 +952,14 @@ ID2D1Bitmap* D2DPixelProcessor2D::implCreateAlpha_Direct(
     if (!aSubContentRenderer.valid())
     {
         // did not work, done
-        return nullptr;
+        return pRetval;
     }
 
     // render sub-content recursively
     aSubContentRenderer.process(rTransCandidate.getTransparence());
 
     // grab Bitmap & prepare results from RGBA content rendering
-    ID2D1Bitmap* pInBetweenResult(aSubContentRenderer.getID2D1Bitmap());
-    ID2D1Bitmap* pRetval(nullptr);
+    sal::systools::COMReference<ID2D1Bitmap> pInBetweenResult(aSubContentRenderer.getID2D1Bitmap());
 
     // Now we need a target to render this to, using the ID2D1Effect tooling.
     // We can directly apply the effect to an alpha-only 8bit target here,
@@ -989,12 +968,12 @@ ID2D1Bitmap* D2DPixelProcessor2D::implCreateAlpha_Direct(
     // to pContent again, but that does not work due to the bitmap
     // fetched being probably only an internal reference to the
     // ID2D1BitmapRenderTarget, thus it would draw onto itself -> chaos
-    ID2D1BitmapRenderTarget* pContent(nullptr);
+    sal::systools::COMReference<ID2D1BitmapRenderTarget> pContent;
     const D2D1_PIXEL_FORMAT aAlphaFormat(
         D2D1::PixelFormat(DXGI_FORMAT_A8_UNORM, D2D1_ALPHA_MODE_STRAIGHT));
     const D2D1_SIZE_U aRenderTargetSizePixel(
         D2D1::SizeU(ceil(rVisibleRange.getWidth()), ceil(rVisibleRange.getHeight())));
-    HRESULT hr(getRenderTarget().CreateCompatibleRenderTarget(
+    const HRESULT hr(getRenderTarget()->CreateCompatibleRenderTarget(
         nullptr, &aRenderTargetSizePixel, &aAlphaFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE,
         &pContent));
 
@@ -1007,7 +986,7 @@ ID2D1Bitmap* D2DPixelProcessor2D::implCreateAlpha_Direct(
         if (pID2D1DeviceContext)
         {
             // create the effect
-            ID2D1Effect* pLuminanceToAlpha(nullptr);
+            sal::systools::COMReference<ID2D1Effect> pLuminanceToAlpha;
             pID2D1DeviceContext->CreateEffect(CLSID_D2D1LuminanceToAlpha, &pLuminanceToAlpha);
 
             if (pLuminanceToAlpha)
@@ -1022,20 +1001,14 @@ ID2D1Bitmap* D2DPixelProcessor2D::implCreateAlpha_Direct(
 
                 // grab result
                 pContent->GetBitmap(&pRetval);
-                pLuminanceToAlpha->Release();
             }
-
-            pID2D1DeviceContext->Release();
         }
-
-        pContent->Release();
     }
 
-    pInBetweenResult->Release();
     return pRetval;
 }
 
-ID2D1Bitmap* D2DPixelProcessor2D::implCreateAlpha_B2DBitmap(
+sal::systools::COMReference<ID2D1Bitmap> D2DPixelProcessor2D::implCreateAlpha_B2DBitmap(
     const primitive2d::TransparencePrimitive2D& rTransCandidate,
     const basegfx::B2DRange& rVisibleRange, D2D1_MATRIX_3X2_F& rMaskScale)
 {
@@ -1062,11 +1035,12 @@ ID2D1Bitmap* D2DPixelProcessor2D::implCreateAlpha_B2DBitmap(
     const AlphaMask aAlpha(::drawinglayer::createAlphaMask(
         std::move(xEmbedSeq), aEmptyViewInformation2D, nDiscreteClippedWidth,
         nDiscreteClippedHeight, nMaximumQuadraticPixels, true));
+    sal::systools::COMReference<ID2D1Bitmap> pRetval;
 
     if (aAlpha.IsEmpty())
     {
         // if we have no content we are done
-        return nullptr;
+        return pRetval;
     }
 
     // use alpha data to create the ID2D1Bitmap
@@ -1088,19 +1062,16 @@ ID2D1Bitmap* D2DPixelProcessor2D::implCreateAlpha_B2DBitmap(
         }
     }
 
-    ID2D1Bitmap* pRetval(nullptr);
     const D2D1_BITMAP_PROPERTIES aBmProps(D2D1::BitmapProperties(
         D2D1::PixelFormat(DXGI_FORMAT_A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED)));
-    HRESULT hr = getRenderTarget().CreateBitmap(
+    const HRESULT hr(getRenderTarget()->CreateBitmap(
         D2D1::SizeU(rSizePixel.Width(), rSizePixel.Height()), &aData[0],
-        rSizePixel.Width() * sizeof(sal_uInt8), &aBmProps, &pRetval);
+        rSizePixel.Width() * sizeof(sal_uInt8), &aBmProps, &pRetval));
 
-    //  D2D1_BITMAP_PROPERTIES
-
-    if (!SUCCEEDED(hr) || nullptr == pRetval)
+    if (!SUCCEEDED(hr) || !pRetval)
     {
         // did not work, done
-        return nullptr;
+        return pRetval;
     }
 
     // create needed adapted transformation for alpha brush.
@@ -1129,16 +1100,22 @@ void D2DPixelProcessor2D::processTransparencePrimitive2D(
     const primitive2d::TransparencePrimitive2D& rTransCandidate)
 {
     if (rTransCandidate.getChildren().empty())
+    {
+        // no content, done
         return;
+    }
 
     if (rTransCandidate.getTransparence().empty())
+    {
+        // no mask (so nothing visible), done
         return;
+    }
 
     // calculate visible range, create only for that range
     basegfx::B2DRange aDiscreteRange(
         rTransCandidate.getChildren().getB2DRange(getViewInformation2D()));
     aDiscreteRange.transform(getViewInformation2D().getObjectToViewTransformation());
-    const D2D1_SIZE_U aB2DSizePixel(getRenderTarget().GetPixelSize());
+    const D2D1_SIZE_U aB2DSizePixel(getRenderTarget()->GetPixelSize());
     const basegfx::B2DRange aViewRange(0.0, 0.0, aB2DSizePixel.width, aB2DSizePixel.height);
     basegfx::B2DRange aVisibleRange(aDiscreteRange);
     aVisibleRange.intersect(aViewRange);
@@ -1150,64 +1127,60 @@ void D2DPixelProcessor2D::processTransparencePrimitive2D(
     }
 
     // try to create directly, this needs the current mpRT to be a ID2D1DeviceContext/d2d1_1
-    // what is not guaranteed but usually works for more modern windows (after 7)
-    ID2D1Bitmap* pAlphaBitmap(implCreateAlpha_Direct(rTransCandidate, aVisibleRange));
+    // what is not guarenteed but usually works for more modern windows (after 7)
+    sal::systools::COMReference<ID2D1Bitmap> pAlphaBitmap(
+        implCreateAlpha_Direct(rTransCandidate, aVisibleRange));
     D2D1_MATRIX_3X2_F aMaskScale(D2D1::Matrix3x2F::Identity());
 
-    if (nullptr == pAlphaBitmap)
+    if (!pAlphaBitmap)
     {
         // did not work, use more expensive fallback to existing tooling
         pAlphaBitmap = implCreateAlpha_B2DBitmap(rTransCandidate, aVisibleRange, aMaskScale);
     }
 
-    if (nullptr == pAlphaBitmap)
+    if (!pAlphaBitmap)
     {
         // could not create alpha channel, error
         increaseError();
         return;
     }
 
-    ID2D1Layer* pLayer = nullptr;
-    HRESULT hr = getRenderTarget().CreateLayer(nullptr, &pLayer);
+    sal::systools::COMReference<ID2D1Layer> pLayer;
+    HRESULT hr(getRenderTarget()->CreateLayer(nullptr, &pLayer));
     bool bDone(false);
 
-    if (SUCCEEDED(hr))
+    if (SUCCEEDED(hr) && pLayer)
     {
-        ID2D1BitmapBrush* pBitmapBrush = nullptr;
-        hr = getRenderTarget().CreateBitmapBrush(pAlphaBitmap, &pBitmapBrush);
+        sal::systools::COMReference<ID2D1BitmapBrush> pBitmapBrush;
+        hr = getRenderTarget()->CreateBitmapBrush(pAlphaBitmap, &pBitmapBrush);
 
-        if (SUCCEEDED(hr))
+        if (SUCCEEDED(hr) && pBitmapBrush)
         {
             // apply MaskScale to Brush, maybe used if implCreateAlpha_B2DBitmap was needed
             pBitmapBrush->SetTransform(aMaskScale);
 
             // need to set transform offset for Layer initialization, we work
             // in discrete device coordinates
-            getRenderTarget().SetTransform(D2D1::Matrix3x2F::Translation(
+            getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Translation(
                 floor(aVisibleRange.getMinX()), floor(aVisibleRange.getMinY())));
 
-            getRenderTarget().PushLayer(D2D1::LayerParameters(D2D1::InfiniteRect(), nullptr,
-                                                              D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,
-                                                              D2D1::Matrix3x2F::Identity(), 1.0,
-                                                              pBitmapBrush),
-                                        pLayer);
+            getRenderTarget()->PushLayer(D2D1::LayerParameters(D2D1::InfiniteRect(), nullptr,
+                                                               D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,
+                                                               D2D1::Matrix3x2F::Identity(), 1.0,
+                                                               pBitmapBrush),
+                                         pLayer);
 
             // ... but need to reset to paint content unchanged
-            getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
+            getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
 
-            // draw content
+            // draw content recursively
             process(rTransCandidate.getChildren());
 
-            getRenderTarget().PopLayer();
+            getRenderTarget()->PopLayer();
             bDone = true;
-            pBitmapBrush->Release();
         }
-
-        pLayer->Release();
     }
 
-    pAlphaBitmap->Release();
-
     if (!bDone)
         increaseError();
 }
@@ -1237,7 +1210,7 @@ void D2DPixelProcessor2D::processUnifiedTransparencePrimitive2D(
     basegfx::B2DRange aTransparencyRange(
         rTransCandidate.getChildren().getB2DRange(getViewInformation2D()));
     aTransparencyRange.transform(getViewInformation2D().getObjectToViewTransformation());
-    const D2D1_SIZE_U aB2DSizePixel(getRenderTarget().GetPixelSize());
+    const D2D1_SIZE_U aB2DSizePixel(getRenderTarget()->GetPixelSize());
     const basegfx::B2DRange aViewRange(0.0, 0.0, aB2DSizePixel.width, aB2DSizePixel.height);
 
     // not visible, done
@@ -1247,25 +1220,22 @@ void D2DPixelProcessor2D::processUnifiedTransparencePrimitive2D(
     }
 
     bool bDone(false);
-    ID2D1Layer* pLayer = nullptr;
-    HRESULT hr = getRenderTarget().CreateLayer(nullptr, &pLayer);
+    sal::systools::COMReference<ID2D1Layer> pLayer;
+    const HRESULT hr(getRenderTarget()->CreateLayer(nullptr, &pLayer));
 
-    if (SUCCEEDED(hr))
+    if (SUCCEEDED(hr) && pLayer)
     {
         // need to set correct transform for Layer initialization, we work
         // in discrete device coordinates
-        getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
-
-        getRenderTarget().PushLayer(
+        getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
+        getRenderTarget()->PushLayer(
             D2D1::LayerParameters(D2D1::InfiniteRect(), nullptr, D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,
                                   D2D1::IdentityMatrix(),
                                   1.0 - rTransCandidate.getTransparence()), // opacity
             pLayer);
         process(rTransCandidate.getChildren());
-        getRenderTarget().PopLayer();
+        getRenderTarget()->PopLayer();
         bDone = true;
-
-        pLayer->Release();
     }
 
     if (!bDone)
@@ -1276,20 +1246,29 @@ void D2DPixelProcessor2D::processMaskPrimitive2DPixel(
     const primitive2d::MaskPrimitive2D& rMaskCandidate)
 {
     if (rMaskCandidate.getChildren().empty())
+    {
+        // no content, done
         return;
+    }
 
     basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask());
 
     if (!aMask.count())
+    {
+        // no mask (so nothing inside), done
         return;
+    }
 
     basegfx::B2DRange aMaskRange(aMask.getB2DRange());
     aMaskRange.transform(getViewInformation2D().getObjectToViewTransformation());
-    const D2D1_SIZE_U aB2DSizePixel(getRenderTarget().GetPixelSize());
+    const D2D1_SIZE_U aB2DSizePixel(getRenderTarget()->GetPixelSize());
     const basegfx::B2DRange aViewRange(0.0, 0.0, aB2DSizePixel.width, aB2DSizePixel.height);
 
     if (!aViewRange.overlaps(aMaskRange))
+    {
+        // not in visible range, done
         return;
+    }
 
     bool bDone(false);
     std::shared_ptr<SystemDependentData_ID2D1PathGeometry> pSystemDependentData_ID2D1MaskGeometry(
@@ -1297,36 +1276,31 @@ void D2DPixelProcessor2D::processMaskPrimitive2DPixel(
 
     if (pSystemDependentData_ID2D1MaskGeometry)
     {
-        ID2D1TransformedGeometry* pTransformedMaskGeometry = nullptr;
+        sal::systools::COMReference<ID2D1TransformedGeometry> pTransformedMaskGeometry;
         const basegfx::B2DHomMatrix& rObjectToView(
             getViewInformation2D().getObjectToViewTransformation());
-        HRESULT hr = aID2D1FactoryProvider.getID2D1Factory()->CreateTransformedGeometry(
+        HRESULT hr(aID2D1GlobalFactoryProvider.getID2D1Factory()->CreateTransformedGeometry(
             pSystemDependentData_ID2D1MaskGeometry->getID2D1PathGeometry(),
             D2D1::Matrix3x2F(rObjectToView.a(), rObjectToView.b(), rObjectToView.c(),
                              rObjectToView.d(), rObjectToView.e(), rObjectToView.f()),
-            &pTransformedMaskGeometry);
+            &pTransformedMaskGeometry));
 
-        if (SUCCEEDED(hr))
+        if (SUCCEEDED(hr) && pTransformedMaskGeometry)
         {
-            ID2D1Layer* pLayer = nullptr;
-            hr = getRenderTarget().CreateLayer(nullptr, &pLayer);
+            sal::systools::COMReference<ID2D1Layer> pLayer;
+            hr = getRenderTarget()->CreateLayer(nullptr, &pLayer);
 
-            if (SUCCEEDED(hr))
+            if (SUCCEEDED(hr) && pLayer)
             {
                 // need to set correct transform for Layer initialization, we work
                 // in discrete device coordinates
-                getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
-
-                getRenderTarget().PushLayer(
+                getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
+                getRenderTarget()->PushLayer(
                     D2D1::LayerParameters(D2D1::InfiniteRect(), pTransformedMaskGeometry), pLayer);
                 process(rMaskCandidate.getChildren());
-                getRenderTarget().PopLayer();
+                getRenderTarget()->PopLayer();
                 bDone = true;
-
-                pLayer->Release();
             }
-
-            pTransformedMaskGeometry->Release();
         }
     }
 
@@ -1338,24 +1312,28 @@ void D2DPixelProcessor2D::processPointArrayPrimitive2D(
     const primitive2d::PointArrayPrimitive2D& rPointArrayCandidate)
 {
     const std::vector<basegfx::B2DPoint>& rPositions(rPointArrayCandidate.getPositions());
+
     if (rPositions.empty())
+    {
+        // no geometry, done
         return;
+    }
 
     const basegfx::BColor aPointColor(
         maBColorModifierStack.getModifiedColor(rPointArrayCandidate.getRGBColor()));
-    ID2D1SolidColorBrush* pColorBrush(nullptr);
+    sal::systools::COMReference<ID2D1SolidColorBrush> pColorBrush;
     D2D1::ColorF aD2DColor(aPointColor.getRed(), aPointColor.getGreen(), aPointColor.getBlue());
-    HRESULT hr = getRenderTarget().CreateSolidColorBrush(aD2DColor, &pColorBrush);
+    const HRESULT hr(getRenderTarget()->CreateSolidColorBrush(aD2DColor, &pColorBrush));
     bool bDone(false);
 
-    if (SUCCEEDED(hr))
+    if (SUCCEEDED(hr) && pColorBrush)
     {
-        getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
+        getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
 
         // To really paint a single pixel I found nothing better than
         // switch off AA and draw a pixel-aligned rectangle
-        const D2D1_ANTIALIAS_MODE aOldAAMode(getRenderTarget().GetAntialiasMode());
-        getRenderTarget().SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
+        const D2D1_ANTIALIAS_MODE aOldAAMode(getRenderTarget()->GetAntialiasMode());
+        getRenderTarget()->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
 
         for (auto const& pos : rPositions)
         {
@@ -1365,12 +1343,11 @@ void D2DPixelProcessor2D::processPointArrayPrimitive2D(
             const double fY(ceil(aDiscretePos.getY()));
             const D2D1_RECT_F rect = { FLOAT(fX), FLOAT(fY), FLOAT(fX), FLOAT(fY) };
 
-            getRenderTarget().DrawRectangle(&rect, pColorBrush);
+            getRenderTarget()->DrawRectangle(&rect, pColorBrush);
         }
 
-        getRenderTarget().SetAntialiasMode(aOldAAMode);
+        getRenderTarget()->SetAntialiasMode(aOldAAMode);
         bDone = true;
-        pColorBrush->Release();
     }
 
     if (!bDone)
@@ -1381,19 +1358,28 @@ void D2DPixelProcessor2D::processMarkerArrayPrimitive2D(
     const primitive2d::MarkerArrayPrimitive2D& rMarkerArrayCandidate)
 {
     const std::vector<basegfx::B2DPoint>& rPositions(rMarkerArrayCandidate.getPositions());
+
     if (rPositions.empty())
+    {
+        // no geometry, done
         return;
+    }
 
     const BitmapEx& rMarker(rMarkerArrayCandidate.getMarker());
+
     if (rMarker.IsEmpty())
+    {
+        // no marker defined, done
         return;
+    }
 
-    ID2D1Bitmap* pD2DBitmap(getOrCreateB2DBitmap(getRenderTarget(), rMarker));
+    sal::systools::COMReference<ID2D1Bitmap> pD2DBitmap(
+        getOrCreateB2DBitmap(getRenderTarget(), rMarker));
     bool bDone(false);
 
-    if (nullptr != pD2DBitmap)
+    if (pD2DBitmap)
     {
-        getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
+        getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
         const Size& rSizePixel(rMarker.GetSizePixel());
         const tools::Long nMiX((rSizePixel.Width() / 2) + 1);
         const tools::Long nMiY((rSizePixel.Height() / 2) + 1);
@@ -1401,8 +1387,8 @@ void D2DPixelProcessor2D::processMarkerArrayPrimitive2D(
         const tools::Long nPlY(rSizePixel.Height() - nMiY);
 
         // draw with non-AA to show unhampered, clear, non-scaled marker
-        const D2D1_ANTIALIAS_MODE aOldAAMode(getRenderTarget().GetAntialiasMode());
-        getRenderTarget().SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
+        const D2D1_ANTIALIAS_MODE aOldAAMode(getRenderTarget()->GetAntialiasMode());
+        getRenderTarget()->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED);
 
         for (auto const& pos : rPositions)
         {
@@ -1413,12 +1399,11 @@ void D2DPixelProcessor2D::processMarkerArrayPrimitive2D(
             const D2D1_RECT_F rect
                 = { FLOAT(fX - nMiX), FLOAT(fY - nMiY), FLOAT(fX + nPlX), FLOAT(fY + nPlY) };
 
-            getRenderTarget().DrawBitmap(pD2DBitmap, &rect);
+            getRenderTarget()->DrawBitmap(pD2DBitmap, &rect);
         }
 
-        getRenderTarget().SetAntialiasMode(aOldAAMode);
+        getRenderTarget()->SetAntialiasMode(aOldAAMode);
         bDone = true;
-        pD2DBitmap->Release();
     }
 
     if (!bDone)
@@ -1438,7 +1423,7 @@ void D2DPixelProcessor2D::processBackgroundColorPrimitive2D(
                                  rBackgroundColorCandidate.getBColor().getBlue(),
                                  1.0 - rBackgroundColorCandidate.getTransparency());
 
-    getRenderTarget().Clear(aD2DColor);
+    getRenderTarget()->Clear(aD2DColor);
 }
 
 void D2DPixelProcessor2D::processModifiedColorPrimitive2D(
@@ -1532,16 +1517,16 @@ void D2DPixelProcessor2D::processPolygonStrokePrimitive2D(
 
     if (pSystemDependentData_ID2D1PathGeometry)
     {
-        ID2D1TransformedGeometry* pTransformedGeometry = nullptr;
+        sal::systools::COMReference<ID2D1TransformedGeometry> pTransformedGeometry;
         const double fAAOffset(getViewInformation2D().getUseAntiAliasing() ? 0.5 : 0.0);
-        HRESULT hr = aID2D1FactoryProvider.getID2D1Factory()->CreateTransformedGeometry(
+        HRESULT hr(aID2D1GlobalFactoryProvider.getID2D1Factory()->CreateTransformedGeometry(
             pSystemDependentData_ID2D1PathGeometry->getID2D1PathGeometry(),
             D2D1::Matrix3x2F(rObjectToView.a(), rObjectToView.b(), rObjectToView.c(),
                              rObjectToView.d(), rObjectToView.e() + fAAOffset,
                              rObjectToView.f() + fAAOffset),
-            &pTransformedGeometry);
+            &pTransformedGeometry));
 
-        if (SUCCEEDED(hr))
+        if (SUCCEEDED(hr) && pTransformedGeometry)
         {
             const basegfx::BColor aLineColor(
                 maBColorModifierStack.getModifiedColor(rLineAttribute.getColor()));
@@ -1553,12 +1538,12 @@ void D2DPixelProcessor2D::processPolygonStrokePrimitive2D(
                 aD2DColor.a = 0.5;
             }
 
-            ID2D1SolidColorBrush* pColorBrush(nullptr);
-            hr = getRenderTarget().CreateSolidColorBrush(aD2DColor, &pColorBrush);
+            sal::systools::COMReference<ID2D1SolidColorBrush> pColorBrush;
+            hr = getRenderTarget()->CreateSolidColorBrush(aD2DColor, &pColorBrush);
 
-            if (SUCCEEDED(hr))
+            if (SUCCEEDED(hr) && pColorBrush)
             {
-                ID2D1StrokeStyle* pStrokeStyle(nullptr);
+                sal::systools::COMReference<ID2D1StrokeStyle> pStrokeStyle;
                 D2D1_CAP_STYLE aCapStyle(D2D1_CAP_STYLE_FLAT);
                 D2D1_LINE_JOIN aLineJoin(D2D1_LINE_JOIN_MITER);
                 const attribute::StrokeAttribute& rStrokeAttribute(
@@ -1598,7 +1583,7 @@ void D2DPixelProcessor2D::processPolygonStrokePrimitive2D(
                         //     nice, but not what we need or is the standard for other graphic systems. Luckily there
                         //     is also D2D1_LINE_JOIN_MITER_OR_BEVEL and (after some search) the page
                         //     https://learn.microsoft.com/en-us/windows/win32/api/d2d1/ne-d2d1-d2d1_line_join
-                        //     which gives some explanation, so that is what we need to use.
+                        //     which gives some explanation, so that is what we need to use here.
                         // (2) Instead of using an angle in radians (15 deg default) MS uses
                         //     "miterLimit is relative to 1/2 LineWidth", so a length. After some experimenting
                         //     it shows that the (better understandable) angle has to be converted to the length
@@ -1607,6 +1592,8 @@ void D2DPixelProcessor2D::processPolygonStrokePrimitive2D(
                         //     experimentally come to a correction value around 0.9925. Since that seems to
                         //     be no obvious numerical value involved somehow (and as long as I find no other
                         //     explanation) I will have to use that.
+                        // NOTE: To find that correction value I usd that handy bRenderDecomposeForCompareInRed
+                        //       and changes in debugger - as work tipp
                         // With both done I can use Direct2D for Miter completely - what is good for speed.
                         aLineJoin = D2D1_LINE_JOIN_MITER_OR_BEVEL;
 
@@ -1647,7 +1634,7 @@ void D2DPixelProcessor2D::processPolygonStrokePrimitive2D(
                     }
                 }
 
-                hr = aID2D1FactoryProvider.getID2D1Factory()->CreateStrokeStyle(
+                hr = aID2D1GlobalFactoryProvider.getID2D1Factory()->CreateStrokeStyle(
                     D2D1::StrokeStyleProperties(aCapStyle, // startCap
                                                 aCapStyle, // endCap
                                                 aCapStyle, // dashCap
@@ -1658,21 +1645,16 @@ void D2DPixelProcessor2D::processPolygonStrokePrimitive2D(
                     bDashUsed ? dashes.data() : nullptr, bDashUsed ? dashes.size() : 0,
                     &pStrokeStyle);
 
-                if (SUCCEEDED(hr))
+                if (SUCCEEDED(hr) && pStrokeStyle)
                 {
-                    getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
-                    getRenderTarget().DrawGeometry(
+                    getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
+                    getRenderTarget()->DrawGeometry(
                         pTransformedGeometry, pColorBrush,
                         // TODO: Hairline LineWidth, see comment at processPolygonHairlinePrimitive2D
                         bHairline ? 1.44 : fDiscreteLineWidth, pStrokeStyle);
                     bDone = true;
-                    pStrokeStyle->Release();
                 }
-
-                pColorBrush->Release();
             }
-
-            pTransformedGeometry->Release();
         }
     }
 
@@ -1696,16 +1678,16 @@ void D2DPixelProcessor2D::processLineRectanglePrimitive2D(
         maBColorModifierStack.getModifiedColor(rLineRectanglePrimitive2D.getBColor()));
     const D2D1::ColorF aD2DColor(aHairlineColor.getRed(), aHairlineColor.getGreen(),
                                  aHairlineColor.getBlue());
-    ID2D1SolidColorBrush* pColorBrush(nullptr);
-    HRESULT hr(getRenderTarget().CreateSolidColorBrush(aD2DColor, &pColorBrush));
+    sal::systools::COMReference<ID2D1SolidColorBrush> pColorBrush;
+    const HRESULT hr(getRenderTarget()->CreateSolidColorBrush(aD2DColor, &pColorBrush));
     bool bDone(false);
 
-    if (SUCCEEDED(hr))
+    if (SUCCEEDED(hr) && pColorBrush)
     {
         const double fAAOffset(getViewInformation2D().getUseAntiAliasing() ? 0.5 : 0.0);
         const basegfx::B2DHomMatrix aLocalTransform(
             getViewInformation2D().getObjectToViewTransformation());
-        getRenderTarget().SetTransform(D2D1::Matrix3x2F(
+        getRenderTarget()->SetTransform(D2D1::Matrix3x2F(
             aLocalTransform.a(), aLocalTransform.b(), aLocalTransform.c(), aLocalTransform.d(),
             aLocalTransform.e() + fAAOffset, aLocalTransform.f() + fAAOffset));
         const basegfx::B2DRange& rRange(rLineRectanglePrimitive2D.getB2DRange());
@@ -1716,7 +1698,7 @@ void D2DPixelProcessor2D::processLineRectanglePrimitive2D(
              * basegfx::B2DVector(1.44, 0.0))
                 .getLength());
 
-        getRenderTarget().DrawRectangle(&rect, pColorBrush, fDiscreteLineWidth);
+        getRenderTarget()->DrawRectangle(&rect, pColorBrush, fDiscreteLineWidth);
         bDone = true;
     }
 
@@ -1736,23 +1718,23 @@ void D2DPixelProcessor2D::processFilledRectanglePrimitive2D(
     const basegfx::BColor aFillColor(
         maBColorModifierStack.getModifiedColor(rFilledRectanglePrimitive2D.getBColor()));
     const D2D1::ColorF aD2DColor(aFillColor.getRed(), aFillColor.getGreen(), aFillColor.getBlue());
-    ID2D1SolidColorBrush* pColorBrush(nullptr);
-    HRESULT hr(getRenderTarget().CreateSolidColorBrush(aD2DColor, &pColorBrush));
+    sal::systools::COMReference<ID2D1SolidColorBrush> pColorBrush;
+    const HRESULT hr(getRenderTarget()->CreateSolidColorBrush(aD2DColor, &pColorBrush));
     bool bDone(false);
 
-    if (SUCCEEDED(hr))
+    if (SUCCEEDED(hr) && pColorBrush)
     {
         const double fAAOffset(getViewInformation2D().getUseAntiAliasing() ? 0.5 : 0.0);
         const basegfx::B2DHomMatrix aLocalTransform(
             getViewInformation2D().getObjectToViewTransformation());
-        getRenderTarget().SetTransform(D2D1::Matrix3x2F(
+        getRenderTarget()->SetTransform(D2D1::Matrix3x2F(
             aLocalTransform.a(), aLocalTransform.b(), aLocalTransform.c(), aLocalTransform.d(),
             aLocalTransform.e() + fAAOffset, aLocalTransform.f() + fAAOffset));
         const basegfx::B2DRange& rRange(rFilledRectanglePrimitive2D.getB2DRange());
         const D2D1_RECT_F rect = { FLOAT(rRange.getMinX()), FLOAT(rRange.getMinY()),
                                    FLOAT(rRange.getMaxX()), FLOAT(rRange.getMaxY()) };
 
-        getRenderTarget().FillRectangle(&rect, pColorBrush);
+        getRenderTarget()->FillRectangle(&rect, pColorBrush);
         bDone = true;
     }
 
@@ -1766,11 +1748,11 @@ void D2DPixelProcessor2D::processSingleLinePrimitive2D(
     const basegfx::BColor aLineColor(
         maBColorModifierStack.getModifiedColor(rSingleLinePrimitive2D.getBColor()));
     const D2D1::ColorF aD2DColor(aLineColor.getRed(), aLineColor.getGreen(), aLineColor.getBlue());
-    ID2D1SolidColorBrush* pColorBrush(nullptr);
-    HRESULT hr(getRenderTarget().CreateSolidColorBrush(aD2DColor, &pColorBrush));
+    sal::systools::COMReference<ID2D1SolidColorBrush> pColorBrush;
+    const HRESULT hr(getRenderTarget()->CreateSolidColorBrush(aD2DColor, &pColorBrush));
     bool bDone(false);
 
-    if (SUCCEEDED(hr))
+    if (SUCCEEDED(hr) && pColorBrush)
     {
         const double fAAOffset(getViewInformation2D().getUseAntiAliasing() ? 0.5 : 0.0);
         basegfx::B2DHomMatrix aLocalTransform(
@@ -1778,13 +1760,13 @@ void D2DPixelProcessor2D::processSingleLinePrimitive2D(
         const basegfx::B2DPoint aStart(aLocalTransform * rSingleLinePrimitive2D.getStart());
         const basegfx::B2DPoint aEnd(aLocalTransform * rSingleLinePrimitive2D.getEnd());
 
-        getRenderTarget().SetTransform(D2D1::Matrix3x2F::Identity());
+        getRenderTarget()->SetTransform(D2D1::Matrix3x2F::Identity());
         const D2D1_POINT_2F aD2D1Start
             = { FLOAT(aStart.getX() + fAAOffset), FLOAT(aStart.getY() + fAAOffset) };
         const D2D1_POINT_2F aD2D1End
             = { FLOAT(aEnd.getX() + fAAOffset), FLOAT(aEnd.getY() + fAAOffset) };
 
-        getRenderTarget().DrawLine(aD2D1Start, aD2D1End, pColorBrush, 1.44f);
+        getRenderTarget()->DrawLine(aD2D1Start, aD2D1End, pColorBrush, 1.44f);
         bDone = true;
     }
 
@@ -1795,12 +1777,19 @@ void D2DPixelProcessor2D::processSingleLinePrimitive2D(
 void D2DPixelProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
 {
     if (0 == mnRecursionCounter)
-        getRenderTarget().BeginDraw();
+        getRenderTarget()->BeginDraw();
     mnRecursionCounter++;
 
     switch (rCandidate.getPrimitive2DID())
     {
-        // geometry that *has* to be processed
+        // Geometry that *has* to be processed
+        //
+        // These Primitives have *no* decompose implementation, so these are the basic ones
+        // Just four to go to make a processor work completely (but not optimized)
+        // NOTE: This *could* theoretically be reduced to one and all could implement
+        //       a decompose to pixel data, but that seemed not to make sense to me when
+        //       I designed this. Thus these four are the lowest-level best representation
+        //       from my POV
         case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D:
         {
             processBitmapPrimitive2D(
@@ -1826,7 +1815,16 @@ void D2DPixelProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitiv
             break;
         }
 
-        // embedding/groups that *have* to be processed
+        // Embedding/groups that *have* to be processed
+        //
+        // These represent qualifiers for freely defined content, e.g. making
+        // any combinatiopn of priitives freely transformed or transparent
+        // NOTE: PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D and
+        //       PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D are pretty much default-
+        //       implementations that cand and are re-used in all processors.
+        // So - with these and PRIMITIVE2D_ID_INVERTPRIMITIVE2D marked to
+        // be removed in the future - just three really to be implemented
+        // locally specifically
         case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D:
         {
             processTransparencePrimitive2D(
@@ -1837,7 +1835,9 @@ void D2DPixelProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitiv
         {
             // TODO: fallback is at VclPixelProcessor2D::processInvertPrimitive2D, so
             // not in reach. Ignore for now.
-            // processInvertPrimitive2D(rCandidate);
+            // NOTE: We *urgently* need to get rid of the last parts in LO that use
+            //       XOR paint. Modern graphic systems allow no read access to the
+            //       pixel targets, but that's naturally a precondition for XOR
             break;
         }
         case PRIMITIVE2D_ID_MASKPRIMITIVE2D:
@@ -1859,52 +1859,70 @@ void D2DPixelProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitiv
             break;
         }
 
-        // geometry that *may* be processed due to being able to do it better
-        // then using the decomposition
+        // Geometry that *may* be processed due to being able to do it better
+        // then using the decomposition.
+        // NOTE: In these implementations you could always call what the default
+        //       case below does - call process(rCandidate) to use the decomposition.
+        //       So these impls should only do something if they can do it better/
+        //       faster that the decomposition. So some of them check if they could
+        //       - and if not - use exactly that.
         case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D:
         {
+            // transparence with a fixed alpha for all content, can be done
+            // significally faster
             processUnifiedTransparencePrimitive2D(
                 static_cast<const primitive2d::UnifiedTransparencePrimitive2D&>(rCandidate));
             break;
         }
         case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D:
         {
+            // can be done simpler and without AA better locally
             processMarkerArrayPrimitive2D(
                 static_cast<const primitive2d::MarkerArrayPrimitive2D&>(rCandidate));
             break;
         }
         case PRIMITIVE2D_ID_BACKGROUNDCOLORPRIMITIVE2D:
         {
+            // reset to a color, can be done more effectively locally, would
+            // else decompose to a polygon fill
             processBackgroundColorPrimitive2D(
                 static_cast<const primitive2d::BackgroundColorPrimitive2D&>(rCandidate));
             break;
         }
         case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
         {
+            // fat and stroked lines - much better doable locally, would decompose
+            // to the full line geometry creation (tesselation)
             processPolygonStrokePrimitive2D(
                 static_cast<const primitive2d::PolygonStrokePrimitive2D&>(rCandidate));
             break;
         }
         case PRIMITIVE2D_ID_LINERECTANGLEPRIMITIVE2D:
         {
+            // simple primitve to support future fast callbacks from OutputDevice
+            // (see 'Example POC' in Gerrit), decomposes to polygon primitive
             processLineRectanglePrimitive2D(
                 static_cast<const primitive2d::LineRectanglePrimitive2D&>(rCandidate));
             break;
         }
         case PRIMITIVE2D_ID_FILLEDRECTANGLEPRIMITIVE2D:
         {
+            // simple primitve to support future fast callbacks from OutputDevice
+            // (see 'Example POC' in Gerrit), decomposes to filled polygon primitive
             processFilledRectanglePrimitive2D(
                 static_cast<const primitive2d::FilledRectanglePrimitive2D&>(rCandidate));
             break;
         }
         case PRIMITIVE2D_ID_SINGLELINEPRIMITIVE2D:
         {
+            // simple primitve to support future fast callbacks from OutputDevice
+            // (see 'Example POC' in Gerrit), decomposes to polygon primitive
             processSingleLinePrimitive2D(
                 static_cast<const primitive2d::SingleLinePrimitive2D&>(rCandidate));
             break;
         }
 
-        // continue with decompose
+        // continue with decompose as fallback
         default:
         {
             SAL_INFO("drawinglayer", "default case for " << drawinglayer::primitive2d::idToString(
@@ -1917,7 +1935,7 @@ void D2DPixelProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitiv
 
     mnRecursionCounter--;
     if (0 == mnRecursionCounter)
-        getRenderTarget().EndDraw();
+        getRenderTarget()->EndDraw();
 }
 } // end of namespace