dotnet 读 WPF 源代码笔记 WriteableBitmap 的渲染和更新是如何实现

        public void AddDirtyRect(Int32Rect dirtyRect)
        {
            WritePreamble();

            if (_lockCount == 0)
            {
                throw new InvalidOperationException(SR.Get(SRID.Image_MustBeLocked));
            }

            //
            // Sanitize the dirty rect.
            //
            dirtyRect.ValidateForDirtyRect("dirtyRect", _pixelWidth, _pixelHeight);
            if (dirtyRect.HasArea)
            {
                MILSwDoubleBufferedBitmap.AddDirtyRect(
                    _pDoubleBufferedBitmap,
                    ref dirtyRect);

                _hasDirtyRects = true;
            }

            // Note: we do not call WritePostscript because we do not want to
            // raise change notifications until the writeable bitmap is unlocked.
        }

        [DllImport(DllImport.MilCore, EntryPoint = "MILSwDoubleBufferedBitmapAddDirtyRect", PreserveSig = false)]
        internal static extern void AddDirtyRect(
            SafeMILHandle /* CSwDoubleBufferedBitmap */ THIS_PTR,
            ref Int32Rect dirtyRect
            );

        private SafeMILHandle _pDoubleBufferedBitmap;   // CSwDoubleBufferedBitmap

HRESULT
MILSwDoubleBufferedBitmapAddDirtyRect(
    __in CSwDoubleBufferedBitmap * THIS_PTR,
    __in const MILRect *pRect
    )
{
    HRESULT hr = S_OK;
    UINT x = 0;
    UINT y = 0;
    UINT width = 0;
    UINT height = 0;
    CMilRectU rcDirty;

    CHECKPTR(THIS_PTR);
    CHECKPTR(pRect);

    IFC(IntToUInt(pRect->X, &x));
    IFC(IntToUInt(pRect->Y, &y));
    IFC(IntToUInt(pRect->Width, &width));
    IFC(IntToUInt(pRect->Height, &height));

    // Since we converted x, y, width, and height from ints, we can add them
    // together and remain within a UINT.
    rcDirty = CMilRectU(x, y, width, height, XYWH_Parameters);

    IFC(THIS_PTR->AddDirtyRect(&rcDirty));

Cleanup:

    RRETURN(hr);
}

HRESULT
CSwDoubleBufferedBitmap::AddDirtyRect(__in const CMilRectU *prcDirty)
{
    HRESULT hr = S_OK;
    CMilRectU rcBounds(0, 0, m_width, m_height, XYWH_Parameters);
    CMilRectU rcDirty = *prcDirty;

    if (!rcDirty.IsEmpty())
    {
        // Each dirty rect will eventually be treated as a RECT, so we must
        // ensure that the Left, Right, Top, and Bottom values never exceed
        // INT_MAX.  We already restrict our dimensions to INT_MAX, so as
        // long as the dirty rect is fully within the bounds of the bitmap,
        // we are safe.
        if (!rcBounds.DoesContain(rcDirty))
        {
            IFC(E_INVALIDARG);
        }

        // Adding a dirty rect that spans the entire bitmap will simply
        // replace all existing dirty rects.
        if (rcDirty.IsEquivalentTo(rcBounds))
        {
            m_pDirtyRects[0] = rcBounds;
            m_numDirtyRects = 1;
        }
        else
        {
            // Check to see if one of the existing dirty rects fully contains the
            // new dirty rect.  If so, there is no need to add it.
            for (UINT i = 0; i < m_numDirtyRects; i++)
            {
                if (m_pDirtyRects[i].DoesContain(rcDirty))
                {
                    // No dirty list change - new dirty rect is already included.
                    goto Cleanup;
                }
            }

            // Collapse existing dirty rects if we're about to exceed our maximum.
            if (m_numDirtyRects >= c_maxBitmapDirtyListSize)
            {
                // Collapse dirty list to a single large rect (including new rect)
                while (m_numDirtyRects > 1)
                {
                    m_pDirtyRects[0].Union(m_pDirtyRects[--m_numDirtyRects]);
                }
                m_pDirtyRects[0].Union(rcDirty);

                Assert(m_numDirtyRects == 1);
            }
            else
            {
                m_pDirtyRects[m_numDirtyRects++] = rcDirty;
            }
        }
    }

Cleanup:

    RRETURN(hr);
}

HRESULT
CSwDoubleBufferedBitmap::CopyForwardDirtyRects()
{
    HRESULT hr = S_OK;

    IWGXBitmapSource *pIWGXBitmapSource = NULL;
    IWGXBitmapLock *pFrontBufferLock = NULL;
    UINT cbLockStride = 0;
    UINT cbBufferSize = 0;
    BYTE *pbSurface = NULL;

    Assert(m_pBackBuffer);

    // 根据调用 AddDirtyRect 方法加入的 DirtyRect 获取当前有哪些需要拷贝的像素
    // This locks only the rect specified as dirty for each copy. It would
    // be more efficient to just lock the entire rect once for all of the
    // copies, but then we need to manually compute offsets into the front
    // buffer specific to each pixel format.
    while (m_numDirtyRects > 0)
    {
        // We have to jump through a few RECT hoops here since
        // IWGXBitmapSource::Lock/CopyPixels take a WICRect and
        // IWGXBitmap::AddDirtyRect takes a GDI RECT, neither of which are
        // CMilRectU which we use in CSwDoubleBufferedBitmap for geometric operations.
        //
        // CMilRectU and RECT share the same memory alignment, but different
        // signs.  Since we restrict the size of our bitmap to MAX_INT, we can
        // safely cast.
        // 这里只是做一层转换而已，拿到当前的一个 DirtyRect 范围
        const RECT *rcDirty = reinterpret_cast<RECT const *>(&m_pDirtyRects[--m_numDirtyRects]);
        WICRect copyRegion = {
            static_cast<int>(rcDirty->left),
            static_cast<int>(rcDirty->top),
            static_cast<int>(rcDirty->right - rcDirty->left),
            static_cast<int>(rcDirty->bottom - rcDirty->top)
            };

        // 根据 IWICBitmapSource 的使用文档，在使用之前需要先加上锁
        // This adds copyRegion as a dirty rect to m_pFrontBuffer automatically.
        IFC(m_pFrontBuffer->Lock(
            &copyRegion,
            MilBitmapLock::Write,
            &pFrontBufferLock
            ));

        IFC(pFrontBufferLock->GetStride(&cbLockStride));
        IFC(pFrontBufferLock->GetDataPointer(&cbBufferSize, &pbSurface));

        // If a format converter has been allocated, it is necessary that we call copy
        // pixels through it rather than directly from the back buffer since its very
        // existence implies that a conversion is needed.
        GetPossiblyFormatConvertedBackBuffer(&pIWGXBitmapSource);

        // 这里的 IFC 是一个宏，表示的是如果返回值是 gg 的，那么 goto 到 Cleanup 标签
        /*
        * #ifndef IFC
          #define IFC(x) { hr = (x); if (FAILED(hr)) goto Cleanup; }
          #endif
        */
        // 下面代码就是核心逻辑，通过 CopyPixels 方法从后面的缓存也就是 WPF 层的数据拷贝到前面的缓存用于显示
        // 在这一层里面其实就丢失了 DirtyRect 信息
        IFC(pIWGXBitmapSource->CopyPixels(
            &copyRegion,
            cbLockStride,
            cbBufferSize,
            pbSurface
            ));

        // 释放掉锁
        // We need to release the lock and format converter here because we are in a loop.
        ReleaseInterface(pIWGXBitmapSource);
        ReleaseInterface(pFrontBufferLock);
    }

Cleanup:
    ReleaseInterfaceNoNULL(pIWGXBitmapSource);
    ReleaseInterfaceNoNULL(pFrontBufferLock);

    RRETURN(hr);
}

    IFC(CWriteProtectedBitmap::Create(width, height, dpiX, dpiY, pixelFormat, pPalette, &pWriteProtectedBitmap));

    pWriteProtectedBitmap->AddRef();
    m_pBackBufferAsWriteProtectedBitmap = pWriteProtectedBitmap;

    // QI to a friendly interface that we'll pass out to the user
    // of this double buffered bitmap.  We ask for the WIC interface instead of
    // the MIL interface so that we can use the extensive set of format
    // converters provided by WIC but not MIL.
    IFC(pWriteProtectedBitmap->QueryInterface(
        IID_IWGXBitmap,
        reinterpret_cast<void**>(&pBackBuffer)
        ));

    IFC(CWGXWrapperBitmap::Create(
        pBackBuffer,
        &m_pBackBuffer
        ));

HRESULT
CWGXWrapperBitmap::Create(
    __in_ecount(1) IWGXBitmap *pIBitmap,
    __deref_out_ecount(1) IWICBitmap **ppWrapper
    )
{
    HRESULT hr = S_OK;

    CWGXWrapperBitmap *pWrapper = new CWGXWrapperBitmap(pIBitmap);
    IFCOOM(pWrapper);
    pWrapper->AddRef();

    *ppWrapper = pWrapper;

Cleanup:
    RRETURN(hr);
}

void
CSwDoubleBufferedBitmap::GetPossiblyFormatConvertedBackBuffer(
    __deref_out IWGXBitmapSource **ppPossiblyFormatConvertedBackBuffer
    ) const
{
    if (m_pFormatConverter)
    {
        SetInterface(*ppPossiblyFormatConvertedBackBuffer, m_pFormatConverter);
    }
    else
    {
        SetInterface(*ppPossiblyFormatConvertedBackBuffer, m_pBackBufferAsWriteProtectedBitmap);
    }
}