Tag Archives: windows imaging component

MFC Support for Direct2D – Part 7: Saving to files

Once have enabled Direct2D support in an MFC application, there is no sweat to load an image from a file, by using one of CD2DBitmap constructors.
Unfortunately, we cannot find a CD2DBitmap method to save it into a image file (something similar to CImage::Save or Gdiplus::Image::Save).
No problem, we can try to do it ourselves. Here is an example:

Create and use a WIC bitmap render target

void CDemoView::SaveImageToFile(CD2DBitmap* pBitmap, const CString& strFilePath, GUID containerFormat)
{
    if (!pBitmap)
        AfxThrowOleException(E_FAIL);

    // Get global Direct2D and WIC factories
    _AFX_D2D_STATE* pD2DState = AfxGetD2DState();
    ID2D1Factory* pD2DFactory = pD2DState->GetDirect2dFactory();
    IWICImagingFactory* pWICFactory = pD2DState->GetWICFactory();
    if (!pD2DFactory || !pWICFactory)
        AfxThrowOleException(E_FAIL);

    // Create a WIC bitmap
    const CD2DSizeF size = pBitmap->GetSize();
    const UINT nWidth = static_cast<UINT>(size.width);
    const UINT nHeight = static_cast<UINT>(size.height);
    CComPtr<IWICBitmap> spWicBitmap;
    HRESULT hr = pWICFactory->CreateBitmap(nWidth, nHeight,
        GUID_WICPixelFormat32bppPBGRA, WICBitmapCacheOnLoad, &spWicBitmap);
    ATLENSURE_SUCCEEDED(hr);

    // Create a Direct2D render target that renders to a WIC bitmap
    ID2D1RenderTarget* pRenderTarget = NULL;
    hr = pD2DFactory->CreateWicBitmapRenderTarget(spWicBitmap,
        &D2D1::RenderTargetProperties(D2D1_RENDER_TARGET_TYPE_SOFTWARE,
            D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED),
            0.f, 0.f, D2D1_RENDER_TARGET_USAGE_NONE),
        &pRenderTarget);
    ATLENSURE_SUCCEEDED(hr);

    // Draw the Direct2D bitmap into created WIC bitmap render target
    CRenderTarget renderTarget;
    renderTarget.Attach(pRenderTarget);
    renderTarget.BeginDraw();
    renderTarget.DrawBitmap(pBitmap, CD2DRectF(0, 0, size.width, size.height));
    hr = renderTarget.EndDraw();
    ATLENSURE_SUCCEEDED(hr);

    // Use WIC stuff to save the WIC bitmap into a file
    CComPtr<IWICStream> spStream;
    hr = pWICFactory->CreateStream(&spStream);
    ATLENSURE_SUCCEEDED(hr);

    hr = spStream->InitializeFromFilename(strFilePath, GENERIC_WRITE);
    ATLENSURE_SUCCEEDED(hr);

    CComPtr<IWICBitmapEncoder> spEncoder;
    hr = pWICFactory->CreateEncoder(containerFormat, NULL, &spEncoder.p);
    ATLENSURE_SUCCEEDED(hr);

    hr = spEncoder->Initialize(spStream, WICBitmapEncoderNoCache);
    ATLENSURE_SUCCEEDED(hr);
    CComPtr<IWICBitmapFrameEncode> spFrameEncode;

    hr = spEncoder->CreateNewFrame(&spFrameEncode, NULL);
    ATLENSURE_SUCCEEDED(hr);

    hr = spFrameEncode->Initialize(NULL);
    ATLENSURE_SUCCEEDED(hr);

    hr = spFrameEncode->SetSize(nWidth, nHeight);
    ATLENSURE_SUCCEEDED(hr);

    WICPixelFormatGUID pixelFormat = GUID_WICPixelFormatDontCare;
    hr = spFrameEncode->SetPixelFormat(&pixelFormat);
    ATLENSURE_SUCCEEDED(hr);

    hr = spFrameEncode->WriteSource(spWicBitmap, NULL);
    ATLENSURE_SUCCEEDED(hr);

    hr = spFrameEncode->Commit();
    ATLENSURE_SUCCEEDED(hr);

    hr = spEncoder->Commit();
    ATLENSURE_SUCCEEDED(hr);
}

void CDemoView::SaveImageToFile(CD2DBitmap* pBitmap, const CString& strFilePath, GUID containerFormat)

{

if (!pBitmap)

AfxThrowOleException(E_FAIL);

// Get global Direct2D and WIC factories

_AFX_D2D_STATE* pD2DState = AfxGetD2DState();

ID2D1Factory* pD2DFactory = pD2DState->GetDirect2dFactory();

IWICImagingFactory* pWICFactory = pD2DState->GetWICFactory();

if (!pD2DFactory || !pWICFactory)

AfxThrowOleException(E_FAIL);

// Create a WIC bitmap

const CD2DSizeF size = pBitmap->GetSize();

const UINT nWidth = static_cast<UINT>(size.width);

const UINT nHeight = static_cast<UINT>(size.height);

CComPtr<IWICBitmap> spWicBitmap;

HRESULT hr = pWICFactory->CreateBitmap(nWidth, nHeight,

GUID_WICPixelFormat32bppPBGRA, WICBitmapCacheOnLoad, &spWicBitmap);

ATLENSURE_SUCCEEDED(hr);

// Create a Direct2D render target that renders to a WIC bitmap

ID2D1RenderTarget* pRenderTarget = NULL;

hr = pD2DFactory->CreateWicBitmapRenderTarget(spWicBitmap,

&D2D1::RenderTargetProperties(D2D1_RENDER_TARGET_TYPE_SOFTWARE,

D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED),

0.f, 0.f, D2D1_RENDER_TARGET_USAGE_NONE),

&pRenderTarget);

ATLENSURE_SUCCEEDED(hr);

// Draw the Direct2D bitmap into created WIC bitmap render target

CRenderTarget renderTarget;

renderTarget.Attach(pRenderTarget);

renderTarget.BeginDraw();

renderTarget.DrawBitmap(pBitmap, CD2DRectF(0, 0, size.width, size.height));

hr = renderTarget.EndDraw();

ATLENSURE_SUCCEEDED(hr);

// Use WIC stuff to save the WIC bitmap into a file

CComPtr<IWICStream> spStream;

hr = pWICFactory->CreateStream(&spStream);

ATLENSURE_SUCCEEDED(hr);

hr = spStream->InitializeFromFilename(strFilePath, GENERIC_WRITE);

ATLENSURE_SUCCEEDED(hr);

CComPtr<IWICBitmapEncoder> spEncoder;

hr = pWICFactory->CreateEncoder(containerFormat, NULL, &spEncoder.p);

ATLENSURE_SUCCEEDED(hr);

hr = spEncoder->Initialize(spStream, WICBitmapEncoderNoCache);

ATLENSURE_SUCCEEDED(hr);

CComPtr<IWICBitmapFrameEncode> spFrameEncode;

hr = spEncoder->CreateNewFrame(&spFrameEncode, NULL);

ATLENSURE_SUCCEEDED(hr);

hr = spFrameEncode->Initialize(NULL);

ATLENSURE_SUCCEEDED(hr);

hr = spFrameEncode->SetSize(nWidth, nHeight);

ATLENSURE_SUCCEEDED(hr);

WICPixelFormatGUID pixelFormat = GUID_WICPixelFormatDontCare;

hr = spFrameEncode->SetPixelFormat(&pixelFormat);

ATLENSURE_SUCCEEDED(hr);

hr = spFrameEncode->WriteSource(spWicBitmap, NULL);

ATLENSURE_SUCCEEDED(hr);

hr = spFrameEncode->Commit();

ATLENSURE_SUCCEEDED(hr);

hr = spEncoder->Commit();

ATLENSURE_SUCCEEDED(hr);

}

Looks good although it can be refactorized and/or can be improved for saving multiple frames, metadata and so on. However, it’s a problem: if the Direct2D bitmap (pBitmap) has been created in the window’s render target, EndDraw returns D2DERR_WRONG_RESOURCE_DOMAIN error (the resource was realized on the wrong render target). That is because CWnd::EnableD2DSupport creates a render target of type D2D1_RENDER_TARGET_TYPE_DEFAULT and as stated in the documentation, it cannot share its resources with another render targets. So, let’s replace EnableD2DSupport call with a call to another one (let’s say it EnableD2DSoftwareSupport).

Replace CWnd::EnableD2DSupport

int CDemoView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (__super::OnCreate(lpCreateStruct) == -1)
        return -1;

    try
    {
        // EnableD2DSupport(); // <-- TODO: remove this!
        EnableD2DSoftwareSupport();
    }
    catch (COleException* e)
    {
        e->ReportError();
        e->Delete();
        return -1;
    }
    return 0;
}

int CDemoView::OnCreate(LPCREATESTRUCT lpCreateStruct)

{

if (__super::OnCreate(lpCreateStruct) == -1)

return -1;

try

{

// EnableD2DSupport(); // <-- TODO: remove this!

EnableD2DSoftwareSupport();

}

catch (COleException* e)

{

e->ReportError();

e->Delete();

return -1;

}

return 0;

}

void CDemoView::EnableD2DSoftwareSupport()
{
    _AFX_D2D_STATE* pD2DState = AfxGetD2DState();
    if (pD2DState == NULL || !pD2DState->InitD2D())
        AfxThrowOleException(E_FAIL); // D2D is not supported by system

    if (IsD2DSupportEnabled())
        return; // Already enabled

    ID2D1Factory* pDirect2DFactory = AfxGetD2DState()->GetDirect2dFactory();
    ID2D1HwndRenderTarget* pHwndRenderTarget = NULL;
    D2D1_PIXEL_FORMAT pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED);
    D2D1_HWND_RENDER_TARGET_PROPERTIES hwndTargetProperties = D2D1::HwndRenderTargetProperties(m_hWnd);
    D2D1_RENDER_TARGET_PROPERTIES targetProperties = D2D1::RenderTargetProperties(D2D1_RENDER_TARGET_TYPE_SOFTWARE, pixelFormat);

    HRESULT hr = pDirect2DFactory->CreateHwndRenderTarget(
        targetProperties,
        hwndTargetProperties,
        &pHwndRenderTarget);
   
    ATLENSURE_SUCCEEDED(hr);

    // instantiate new CHwndRenderTarget and attach the GDI-compatible render target
    m_pRenderTarget = new CHwndRenderTarget;
    GetRenderTarget()->Attach(pHwndRenderTarget);
}

void CDemoView::EnableD2DSoftwareSupport()

{

_AFX_D2D_STATE* pD2DState = AfxGetD2DState();

if (pD2DState == NULL || !pD2DState->InitD2D())

AfxThrowOleException(E_FAIL); // D2D is not supported by system

if (IsD2DSupportEnabled())

return; // Already enabled

ID2D1Factory* pDirect2DFactory = AfxGetD2DState()->GetDirect2dFactory();

ID2D1HwndRenderTarget* pHwndRenderTarget = NULL;

D2D1_PIXEL_FORMAT pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED);

D2D1_HWND_RENDER_TARGET_PROPERTIES hwndTargetProperties = D2D1::HwndRenderTargetProperties(m_hWnd);

D2D1_RENDER_TARGET_PROPERTIES targetProperties = D2D1::RenderTargetProperties(D2D1_RENDER_TARGET_TYPE_SOFTWARE, pixelFormat);

HRESULT hr = pDirect2DFactory->CreateHwndRenderTarget(

targetProperties,

hwndTargetProperties,

&pHwndRenderTarget);

ATLENSURE_SUCCEEDED(hr);

// instantiate new CHwndRenderTarget and attach the GDI-compatible render target

m_pRenderTarget = new CHwndRenderTarget;

GetRenderTarget()->Attach(pHwndRenderTarget);

}

More details can be found in the demo application attached below. Just to note that forcing software rendering for window’s render target leads in performance penalty but generally, we can live with that until finding a better solution. 🙂

Demo application

The demo application is a simple image viewer using MFC support for Direct2D and WIC to load/save images from/into into files.
Download: Save Direct2D bitmap in a file - Demo.zip (1132)

Resources and related articles

MSDN: Sharing Render Target Resources
MSDN: How to save Direct2D content to an image file
MSDN: Direct2D Error Codes
MSDN: ID2D1Factory::CreateWicBitmapRenderTarget method
Stackoverflow: Wrong render target ID2D1Bitmap
Codexpert: WIC topics
Codexpert: Direc2D topics

Enumerate WIC Components

CComponentEnumT – a template class for enumerating WIC components

namespace wic
{
    template<class TCompInfoCls, DWORD dwTypes>
    class CComponentEnumT
    {
        // ...
    public:
        using CompInfoList = std::list<std::shared_ptr<TCompInfoCls>>;
        using EnumOptions = WICComponentEnumerateOptions;

        CComponentEnumT()
        {
            HRESULT hr = m_spWICFactory.CoCreateInstance(CLSID_WICImagingFactory);
            ATLENSURE_SUCCEEDED(hr);
        }
        ~CComponentEnumT() = default;
        const CompInfoList& DoEnum(EnumOptions opt = WICComponentEnumerateDefault)
        {
            m_listCompInfo.clear();
            CComPtr<IEnumUnknown> spEnum;
            HRESULT hr = m_spWICFactory->CreateComponentEnumerator(dwTypes, opt, &spEnum);
            ATLENSURE_SUCCEEDED(hr);

            ULONG cbActual = 0;
            CComPtr<IUnknown> spEnumElement = NULL;
            while (S_OK == spEnum->Next(1, &spEnumElement, &cbActual))
            {
                auto spCompInfo = std::make_shared<TCompInfoCls>(spEnumElement);
                m_listCompInfo.push_back(spCompInfo);
                spEnumElement = nullptr;
            }
            return m_listCompInfo;
        }

    private:
        CompInfoList m_listCompInfo;
        CComPtr<IWICImagingFactory> m_spWICFactory;
    };
}

namespace wic

{

template<class TCompInfoCls, DWORD dwTypes>

class CComponentEnumT

{

// ...

public:

using CompInfoList = std::list<std::shared_ptr<TCompInfoCls>>;

using EnumOptions = WICComponentEnumerateOptions;

CComponentEnumT()

{

HRESULT hr = m_spWICFactory.CoCreateInstance(CLSID_WICImagingFactory);

ATLENSURE_SUCCEEDED(hr);

}

~CComponentEnumT() = default;

const CompInfoList& DoEnum(EnumOptions opt = WICComponentEnumerateDefault)

{

m_listCompInfo.clear();

CComPtr<IEnumUnknown> spEnum;

HRESULT hr = m_spWICFactory->CreateComponentEnumerator(dwTypes, opt, &spEnum);

ATLENSURE_SUCCEEDED(hr);

ULONG cbActual = 0;

CComPtr<IUnknown> spEnumElement = NULL;

while (S_OK == spEnum->Next(1, &spEnumElement, &cbActual))

{

auto spCompInfo = std::make_shared<TCompInfoCls>(spEnumElement);

m_listCompInfo.push_back(spCompInfo);

spEnumElement = nullptr;

}

return m_listCompInfo;

}

private:

CompInfoList m_listCompInfo;

CComPtr<IWICImagingFactory> m_spWICFactory;

};

}

CComponentInfoBaseT – base class for all other component info classes

namespace wic
{
    template <class TCompInfoInterface>
    class CComponentInfoBaseT
    {
        // ...
    protected:
        CComponentInfoBaseT(const CComPtr<IUnknown>& spEnumElement)
        {
            ATLASSERT(spEnumElement);
            m_spCompInfo = spEnumElement;
        }
        ~CComponentInfoBaseT() = default;

        // data
        CComQIPtr<TCompInfoInterface> m_spCompInfo;
    };
}

namespace wic

{

template <class TCompInfoInterface>

class CComponentInfoBaseT

{

// ...

protected:

CComponentInfoBaseT(const CComPtr<IUnknown>& spEnumElement)

{

ATLASSERT(spEnumElement);

m_spCompInfo = spEnumElement;

}

~CComponentInfoBaseT() = default;

// data

CComQIPtr<TCompInfoInterface> m_spCompInfo;

};

}

CPixelFormatInfoT – just one of classes getting WIC component info

namespace wic
{
    template <class TCompInfoInterface>
    class CPixelFormatInfoT : public CComponentInfoT<TCompInfoInterface>
    {
    public:
        CPixelFormatInfoT(const CComPtr<IUnknown>& spEnumElement);
        ~CPixelFormatInfoT();

        UINT GetBitsPerPixel() const;
        UINT GetChannelCount() const;
        GUID GetFormatGUID() const;
        bool SupportsTransparency() const;
        WICPixelFormatNumericRepresentation GetNumericRepresentation() const;
    };

    using CPixelFormatInfo = CPixelFormatInfoT<IWICPixelFormatInfo2>;
}

namespace wic

{

template <class TCompInfoInterface>

class CPixelFormatInfoT : public CComponentInfoT<TCompInfoInterface>

{

public:

CPixelFormatInfoT(const CComPtr<IUnknown>& spEnumElement);

~CPixelFormatInfoT();

UINT GetBitsPerPixel() const;

UINT GetChannelCount() const;

GUID GetFormatGUID() const;

bool SupportsTransparency() const;

WICPixelFormatNumericRepresentation GetNumericRepresentation() const;

};

using CPixelFormatInfo = CPixelFormatInfoT<IWICPixelFormatInfo2>;

}

Just note that, for further easier using, I’ve defined here CPixelFormatInfo, an alias for CPixelFormatInfoT<IWICPixelFormatInfo2>.

CComponentEnumT specializations and aliases

namespace wic
{
    using CAllComponentEnum = CComponentEnumT<CComponentInfo, WICAllComponents>;
    using CBitmapDecoderEnum = CComponentEnumT<CBitmapCodecInfo, WICDecoder>;
    using CBitmapEncoderEnum = CComponentEnumT<CBitmapCodecInfo, WICEncoder>;
    using CBitmapCodecEnum = CComponentEnumT<CBitmapCodecInfo, WICDecoder | WICEncoder>;
    using CPixelFormatEnum = CComponentEnumT<CPixelFormatInfo, WICPixelFormat>;
    using CMetadataReaderEnum = CComponentEnumT<CMetadataHandlerInfo, WICMetadataReader>;
    using CMetadataWriterEnum = CComponentEnumT<CMetadataHandlerInfo, WICMetadataWriter>;
    using CMetadataHandlerEnum = CComponentEnumT<CMetadataHandlerInfo, WICMetadataReader | WICMetadataWriter>;
    using CFormatConverterEnum = CComponentEnumT<CFormatConverterInfo, WICPixelFormatConverter>;
}

namespace wic

{

using CAllComponentEnum = CComponentEnumT<CComponentInfo, WICAllComponents>;

using CBitmapDecoderEnum = CComponentEnumT<CBitmapCodecInfo, WICDecoder>;

using CBitmapEncoderEnum = CComponentEnumT<CBitmapCodecInfo, WICEncoder>;

using CBitmapCodecEnum = CComponentEnumT<CBitmapCodecInfo, WICDecoder | WICEncoder>;

using CPixelFormatEnum = CComponentEnumT<CPixelFormatInfo, WICPixelFormat>;

using CMetadataReaderEnum = CComponentEnumT<CMetadataHandlerInfo, WICMetadataReader>;

using CMetadataWriterEnum = CComponentEnumT<CMetadataHandlerInfo, WICMetadataWriter>;

using CMetadataHandlerEnum = CComponentEnumT<CMetadataHandlerInfo, WICMetadataReader | WICMetadataWriter>;

using CFormatConverterEnum = CComponentEnumT<CFormatConverterInfo, WICPixelFormatConverter>;

}

Finally, let’s see how to use these classes!

Enumerating WIC pixel formats

void CDemo_MFCDlg::EnumWICPixelFormats(WICComponentEnumerateOptions opt)
{
    wic::CPixelFormatEnum wicEnum;
    const auto& list = wicEnum.DoEnum(opt);
    for (const auto& spItem : list)
    {
        m_editReport.PrintComponentAttributes(spItem);
        m_editReport.PrintPixelFormatAttributes(spItem);
    }
}

void CDemo_MFCDlg::EnumWICPixelFormats(WICComponentEnumerateOptions opt)

{

wic::CPixelFormatEnum wicEnum;

const auto& list = wicEnum.DoEnum(opt);

for (const auto& spItem : list)

{

m_editReport.PrintComponentAttributes(spItem);

m_editReport.PrintPixelFormatAttributes(spItem);

}

Quite easy, isn’t it?

Get the pixel format info

template<class T> void CWICReportEdit::PrintPixelFormatAttributes(T& spItem)
{
    PrintLineV(_T("Bits per pixel:       %u"), spItem->GetBitsPerPixel());
    PrintLineV(_T("Channel count:        %u"), spItem->GetChannelCount());
    // ...
}
// Easy, as well.

template<class T> void CWICReportEdit::PrintPixelFormatAttributes(T& spItem)

{

PrintLineV(_T("Bits per pixel: %u"), spItem->GetBitsPerPixel());

PrintLineV(_T("Channel count: %u"), spItem->GetChannelCount());

// ...

}

// Easy, as well.

You can find the complete source code in the attached demo solution.

Demo solution

Download: Enumerate WIC Components - Demo Solution.zip (881)

Enumerate WIC Components – Demo

The demo solution contains an MFC and a console project that use the classes described above in order to enumerate WIC components and get info about each one. The MFC one allows choosing the component type(s) as well as enum options (include the disabled components or enum only Windows built-in components). The console application is simpler and I wrote it just to demonstrate that my little library of wrapper classes can be used both in MFC and non-MFC applications.

Notes

I hope, this article can be useful.
If you have any observation or remarks, please do not hesitate to post a reply!

Resources and related articles

Codexpert blog: How to enumerate WIC codecs?
MSDN: Windows Imaging Component (WIC) Interfaces

Read IFD and EXIF Metadata with WIC and MFC

Reading IFD and EXIF metadata from a JPEG file

Here is a brief example:

void CWhateverMFCClass::ReadJPEGFileMetadata(LPCWSTR wzFilePath)
{
    // get IWICImagingFactory from global _AFX_D2D_STATE structure
    _AFX_D2D_STATE* pD2DState = AfxGetD2DState();
    IWICImagingFactory* pImagingFactory = pD2DState->GetWICFactory();
    ATLASSERT(pImagingFactory);

    try
    {
        // create bitmap decoder based on the given file
        CComPtr<IWICBitmapDecoder> spBitmapDecoder;
        HRESULT hr = pImagingFactory->CreateDecoderFromFilename(wzFilePath, NULL,
            GENERIC_READ, WICDecodeMetadataCacheOnDemand, &spBitmapDecoder);
        ATLENSURE_SUCCEEDED(hr);

        // get first image frame
        CComPtr<IWICBitmapFrameDecode> spBitmapFrameDecode;
        hr = spBitmapDecoder->GetFrame(0, &spBitmapFrameDecode);
        ATLENSURE_SUCCEEDED(hr);

        // get root metadata reader
        CComPtr<IWICMetadataQueryReader> spRootQueryReader;
        hr = spBitmapFrameDecode->GetMetadataQueryReader(&spRootQueryReader);
        ATLENSURE_SUCCEEDED(hr);

        PROPVARIANT value;
        ::PropVariantInit(&value);

        // get camera model
        CString strModel;
        hr = spRootQueryReader->GetMetadataByName(L"/app1/ifd/{ushort=272}", &value);
        if (SUCCEEDED(hr) && (value.vt == VT_LPSTR))
            strModel = CA2T(value.pszVal);
        ::PropVariantClear(&value);

        // get the date and time when the image was digitized
        CString strDateTimeDigitized;
        hr = spRootQueryReader->GetMetadataByName(L"/app1/ifd/exif/{ushort=36868}", &value);
        if(SUCCEEDED(hr) && (value.vt == VT_LPSTR))
            strDateTimeDigitized = CA2T(value.pszVal);
        ::PropVariantClear(&value);

        // and so on, and so on...
    }
    catch (COleException* e)
    {
        e->ReportError();
        e->Delete();
    }
}

void CWhateverMFCClass::ReadJPEGFileMetadata(LPCWSTR wzFilePath)

{

// get IWICImagingFactory from global _AFX_D2D_STATE structure

_AFX_D2D_STATE* pD2DState = AfxGetD2DState();

IWICImagingFactory* pImagingFactory = pD2DState->GetWICFactory();

ATLASSERT(pImagingFactory);

try

{

// create bitmap decoder based on the given file

CComPtr<IWICBitmapDecoder> spBitmapDecoder;

HRESULT hr = pImagingFactory->CreateDecoderFromFilename(wzFilePath, NULL,

GENERIC_READ, WICDecodeMetadataCacheOnDemand, &spBitmapDecoder);

ATLENSURE_SUCCEEDED(hr);

// get first image frame

CComPtr<IWICBitmapFrameDecode> spBitmapFrameDecode;

hr = spBitmapDecoder->GetFrame(0, &spBitmapFrameDecode);

ATLENSURE_SUCCEEDED(hr);

// get root metadata reader

CComPtr<IWICMetadataQueryReader> spRootQueryReader;

hr = spBitmapFrameDecode->GetMetadataQueryReader(&spRootQueryReader);

ATLENSURE_SUCCEEDED(hr);

PROPVARIANT value;

::PropVariantInit(&value);

// get camera model

CString strModel;

hr = spRootQueryReader->GetMetadataByName(L"/app1/ifd/{ushort=272}", &value);

if (SUCCEEDED(hr) && (value.vt == VT_LPSTR))

strModel = CA2T(value.pszVal);

::PropVariantClear(&value);

// get the date and time when the image was digitized

CString strDateTimeDigitized;

hr = spRootQueryReader->GetMetadataByName(L"/app1/ifd/exif/{ushort=36868}", &value);

if(SUCCEEDED(hr) && (value.vt == VT_LPSTR))

strDateTimeDigitized = CA2T(value.pszVal);

::PropVariantClear(&value);

// and so on, and so on...

}

catch (COleException* e)

{

e->ReportError();

e->Delete();

}

As can be seen, this example assumes that we have a JPEG file and uses the root metadata query reader by passing the item full path.
Let’s improve it in order to read metadata also from TIFF, NEF and other formats. Let’s also get and use the embedded metadata readers both for IFD and EXIF blocks.

Reading IFD and EXIF metadata from an image file

First, we need a functions which finds out if we are dealing with JPEG or other format.

BOOL CWhateverMFCClass::IsJPEGFileFormat(CComPtr<IWICBitmapDecoder> spBitmapDecoder)
{
    GUID guidFormat = {0};
    HRESULT hr = spBitmapDecoder->GetContainerFormat(&guidFormat);
    ATLENSURE_SUCCEEDED(hr);

    return IsEqualGUID(guidFormat, GUID_ContainerFormatJpeg);
}

BOOL CWhateverMFCClass::IsJPEGFileFormat(CComPtr<IWICBitmapDecoder> spBitmapDecoder)

{

GUID guidFormat = {0};

HRESULT hr = spBitmapDecoder->GetContainerFormat(&guidFormat);

ATLENSURE_SUCCEEDED(hr);

return IsEqualGUID(guidFormat, GUID_ContainerFormatJpeg);

}

Next, we can write a function that gets the IFD query reader.

HRESULT CWhateverMFCClass::GetIfdQueryReader(
    CComPtr<IWICBitmapDecoder> spBitmapDecoder,
    CComPtr<IWICMetadataQueryReader> spRootQueryReader,
    CComPtr<IWICMetadataQueryReader>& spQueryReader)
{
    LPWSTR wszIFDPath = L"/ifd";
    if (IsJPEGFileFormat(spBitmapDecoder))
        wszIFDPath = L"/app1/ifd";

    PROPVARIANT value;
    ::PropVariantInit(&value);
    HRESULT hr = spRootQueryReader->GetMetadataByName(wszIFDPath, &value);
    if (FAILED(hr))
        return hr;
    else if (value.vt != VT_UNKNOWN)
        return E_FAIL;

    return value.punkVal->QueryInterface(IID_IWICMetadataQueryReader, (void**)&spQueryReader);
}

HRESULT CWhateverMFCClass::GetIfdQueryReader(

CComPtr<IWICBitmapDecoder> spBitmapDecoder,

CComPtr<IWICMetadataQueryReader> spRootQueryReader,

CComPtr<IWICMetadataQueryReader>& spQueryReader)

{

LPWSTR wszIFDPath = L"/ifd";

if (IsJPEGFileFormat(spBitmapDecoder))

wszIFDPath = L"/app1/ifd";

PROPVARIANT value;

::PropVariantInit(&value);

HRESULT hr = spRootQueryReader->GetMetadataByName(wszIFDPath, &value);

if (FAILED(hr))

return hr;

else if (value.vt != VT_UNKNOWN)

return E_FAIL;

return value.punkVal->QueryInterface(IID_IWICMetadataQueryReader, (void**)&spQueryReader);

}

Also we need a function to get the embedded EXIF query reader. Here we can write a generic one, which takes the parent query reader and the block name.

HRESULT CWhateverMFCClass::GetEmbeddedQueryReader(CComPtr<IWICMetadataQueryReader> spParentQueryReader,
    LPCWSTR wszBlockName,
    CComPtr<IWICMetadataQueryReader>& spQueryReader)
{
    PROPVARIANT value;
    ::PropVariantInit(&value);
    HRESULT hr = spParentQueryReader->GetMetadataByName(wszBlockName, &value);
    if (FAILED(hr))
        return hr;
    else if (value.vt != VT_UNKNOWN)
        return E_FAIL;

    return value.punkVal->QueryInterface(IID_IWICMetadataQueryReader, (void**)&spQueryReader);
}

HRESULT CWhateverMFCClass::GetEmbeddedQueryReader(CComPtr<IWICMetadataQueryReader> spParentQueryReader,

LPCWSTR wszBlockName,

CComPtr<IWICMetadataQueryReader>& spQueryReader)

{

PROPVARIANT value;

::PropVariantInit(&value);

HRESULT hr = spParentQueryReader->GetMetadataByName(wszBlockName, &value);

if (FAILED(hr))

return hr;

else if (value.vt != VT_UNKNOWN)

return E_FAIL;

return value.punkVal->QueryInterface(IID_IWICMetadataQueryReader, (void**)&spQueryReader);

}

Let’a also write a function that gets the root query reader.

HRESULT CWhateverMFCClass::GetRootQueryReader(CComPtr<IWICBitmapDecoder> spBitmapDecoder,
    CComPtr<IWICMetadataQueryReader>& spRootQueryReader)
{
    // get first image frame
    CComPtr<IWICBitmapFrameDecode> spBitmapFrameDecode;
    HRESULT hr = spBitmapDecoder->GetFrame(0, &spBitmapFrameDecode);
    if (FAILED(hr))
        return hr;

    return spBitmapFrameDecode->GetMetadataQueryReader(&spRootQueryReader);
}

HRESULT CWhateverMFCClass::GetRootQueryReader(CComPtr<IWICBitmapDecoder> spBitmapDecoder,

CComPtr<IWICMetadataQueryReader>& spRootQueryReader)

{

// get first image frame

CComPtr<IWICBitmapFrameDecode> spBitmapFrameDecode;

HRESULT hr = spBitmapDecoder->GetFrame(0, &spBitmapFrameDecode);

if (FAILED(hr))

return hr;

return spBitmapFrameDecode->GetMetadataQueryReader(&spRootQueryReader);

}

Now, the function which reads the image IFD and EXIF metadata may look like this:

void ReadImageFileMetadata(LPCWSTR wzFilePath)
{
    // get IWICImagingFactory from global _AFX_D2D_STATE structure
    _AFX_D2D_STATE* pD2DState = AfxGetD2DState();
    IWICImagingFactory* pImagingFactory = pD2DState->GetWICFactory();
    ATLASSERT(pImagingFactory);

    try
    {
        // create bitmap decoder based on the given file
        CComPtr<IWICBitmapDecoder> spBitmapDecoder;
        HRESULT hr = pImagingFactory->CreateDecoderFromFilename(wzFilePath, NULL,
            GENERIC_READ, WICDecodeMetadataCacheOnDemand, &spBitmapDecoder);
        ATLENSURE_SUCCEEDED(hr);

        // get root metadata reader
        CComPtr<IWICMetadataQueryReader> spRootQueryReader; 
        hr = GetRootQueryReader(spBitmapDecoder, spRootQueryReader); 
        ATLENSURE_SUCCEEDED(hr); 

        // get IFD query reader 
        CComPtr<IWICMetadataQueryReader> spIfdQueryReader; 
        hr = GetIfdQueryReader(spBitmapDecoder, spRootQueryReader, spIfdQueryReader); 
        ATLENSURE_SUCCEEDED(hr); 

        PROPVARIANT value; 
        ::PropVariantInit(&value); 

        // get camera model 
        CString strModel; 
        hr = spIfdQueryReader->GetMetadataByName(L"/{ushort=272}", &value);
        if (SUCCEEDED(hr) && (value.vt == VT_LPSTR))
            strModel = CA2T(value.pszVal);
        ::PropVariantClear(&value);

        // read other IFD values...

        // get embedded EXIF query reader
        CComPtr<IWICMetadataQueryReader> spExifQueryReader;
        hr = GetEmbeddedQueryReader(spIfdQueryReader, L"/exif", spExifQueryReader);
        ATLENSURE_SUCCEEDED(hr);

        // get the date and time when the image was digitized
        CString strDateTimeDigitized;
        hr = spExifQueryReader->GetMetadataByName(L"/{ushort=36868}", &value);
        if (SUCCEEDED(hr) && (value.vt == VT_LPSTR))
            strDateTimeDigitized = CA2T(value.pszVal);
        ::PropVariantClear(&value);

        // read other EXIF values...
    }
    catch (CException* e)
    {
        e->ReportError();
        e->Delete();
    }
}

void ReadImageFileMetadata(LPCWSTR wzFilePath)

{

// get IWICImagingFactory from global _AFX_D2D_STATE structure

_AFX_D2D_STATE* pD2DState = AfxGetD2DState();

IWICImagingFactory* pImagingFactory = pD2DState->GetWICFactory();

ATLASSERT(pImagingFactory);

try

{

// create bitmap decoder based on the given file

CComPtr<IWICBitmapDecoder> spBitmapDecoder;

HRESULT hr = pImagingFactory->CreateDecoderFromFilename(wzFilePath, NULL,

GENERIC_READ, WICDecodeMetadataCacheOnDemand, &spBitmapDecoder);

ATLENSURE_SUCCEEDED(hr);

// get root metadata reader

CComPtr<IWICMetadataQueryReader> spRootQueryReader;

hr = GetRootQueryReader(spBitmapDecoder, spRootQueryReader);

ATLENSURE_SUCCEEDED(hr);

// get IFD query reader

CComPtr<IWICMetadataQueryReader> spIfdQueryReader;

hr = GetIfdQueryReader(spBitmapDecoder, spRootQueryReader, spIfdQueryReader);

ATLENSURE_SUCCEEDED(hr);

PROPVARIANT value;

::PropVariantInit(&value);

// get camera model

CString strModel;

hr = spIfdQueryReader->GetMetadataByName(L"/{ushort=272}", &value);

if (SUCCEEDED(hr) && (value.vt == VT_LPSTR))

strModel = CA2T(value.pszVal);

::PropVariantClear(&value);

// read other IFD values...

// get embedded EXIF query reader

CComPtr<IWICMetadataQueryReader> spExifQueryReader;

hr = GetEmbeddedQueryReader(spIfdQueryReader, L"/exif", spExifQueryReader);

ATLENSURE_SUCCEEDED(hr);

// get the date and time when the image was digitized

CString strDateTimeDigitized;

hr = spExifQueryReader->GetMetadataByName(L"/{ushort=36868}", &value);

if (SUCCEEDED(hr) && (value.vt == VT_LPSTR))

strDateTimeDigitized = CA2T(value.pszVal);

::PropVariantClear(&value);

// read other EXIF values...

}

catch (CException* e)

{

e->ReportError();

e->Delete();

}

It’s a little bit better than the previous example but still needs to be completed and a lot of code refactoring. I’ll do that in a future article to present a “full featured” IFD/EXIF metadata reader.

References and related articles

MSDN: Processing Image Metadata
Codexpert blog: Getting Direct2D, DirectWrite and WIC Factories in MFC

Using Direct2D for Rendering WIC Bitmap Sources

3 Replies

Once having a WIC (Windows Imaging Component) source, we can render it by using GDI, GDI+ or Direct2D. There are many examples over the internet including MSDN Library that describes how to perform this.
This article describes how to use WIC Wrapper Library, which is designed for using WIC without worrying about directly deal with COM interfaces. The sample code as well as attached demo project uses MFC, but WIC Wrapper Library can be used in ATL or raw-Win32 projects, as well.

Let’s see the code, step by step!

Add WIC and Direc2D factoy members to the aplication class.

// DemoImageViewer.h
// ...
#include "WicWrapperLibrary.h"
// ...
class CDemoImageViewerApp : public CWinAppEx
{
private:
    std::shared_ptr<ns::wic::ImagingFactory> m_pWICImagingFactory;
    std::shared_ptr<ns::d2d1::Factory>       m_pDirect2DFactory;

public:
    std::shared_ptr<ns::wic::ImagingFactory> GetWICImagingFactory() {return m_pWICImagingFactory;}
    std::shared_ptr<ns::d2d1::Factory> GetDirect2DFactory() {return m_pDirect2DFactory;}
//...
};

// DemoImageViewer.h

// ...

#include "WicWrapperLibrary.h"

// ...

class CDemoImageViewerApp : public CWinAppEx

{

private:

std::shared_ptr<ns::wic::ImagingFactory> m_pWICImagingFactory;

std::shared_ptr<ns::d2d1::Factory> m_pDirect2DFactory;

public:

std::shared_ptr<ns::wic::ImagingFactory> GetWICImagingFactory() {return m_pWICImagingFactory;}

std::shared_ptr<ns::d2d1::Factory> GetDirect2DFactory() {return m_pDirect2DFactory;}

//...

};

Create WIC and Direc2D factory instances after initializing OLE libraries.

BOOL CDemoImageViewerApp::InitInstance()
{
    // ...
    // Initialize OLE libraries
    if (!AfxOleInit())
    {
        AfxMessageBox(IDP_OLE_INIT_FAILED);
        return FALSE;
    }

    try
    {
        // create WIC Imaging Factory instance
        m_pWICImagingFactory = std::make_shared<ns::wic::ImagingFactory>();
        m_pWICImagingFactory->CreateInstance();

        // Create Direct2D Factory instance
        m_pDirect2DFactory = std::make_shared<ns::d2d1::Factory>();
        m_pDirect2DFactory->CreateInstance();
    }
    catch(CException* e)
    {
        e->ReportError();
        e->Delete();
        return FALSE;
    }
    // ...
}

BOOL CDemoImageViewerApp::InitInstance()

{

// ...

// Initialize OLE libraries

if (!AfxOleInit())

{

AfxMessageBox(IDP_OLE_INIT_FAILED);

return FALSE;

}

try

{

// create WIC Imaging Factory instance

m_pWICImagingFactory = std::make_shared<ns::wic::ImagingFactory>();

m_pWICImagingFactory->CreateInstance();

// Create Direct2D Factory instance

m_pDirect2DFactory = std::make_shared<ns::d2d1::Factory>();

m_pDirect2DFactory->CreateInstance();

}

catch(CException* e)

{

e->ReportError();

e->Delete();

return FALSE;

}

// ...

}

Release factories befor calling AfxOleTerm.

int CDemoImageViewerApp::ExitInstance()
{
    // release WIC Imaging and Direct2D Factory instances
    m_pWICImagingFactory->ReleaseInstance();
    m_pDirect2DFactory->ReleaseInstance();

    AfxOleTerm(FALSE);

    return CWinAppEx::ExitInstance();
}

int CDemoImageViewerApp::ExitInstance()

{

// release WIC Imaging and Direct2D Factory instances

m_pWICImagingFactory->ReleaseInstance();

m_pDirect2DFactory->ReleaseInstance();

AfxOleTerm(FALSE);

return CWinAppEx::ExitInstance();

}

Add WIC bitmap source member to document class then override CDocument::OnOpenDocument and CDocument::DeleteContents. Also add an implementation function that loads the WIC bitmap source from a file.

// DemoImageViewerDoc.h
// ...
class CDemoImageViewerDoc : public CDocument
{
    // Attributes
private:
    std::shared_ptr<ns::wic::FormatConverter> m_pWICBitmapSource;

    // Operations
public:
    std::shared_ptr<ns::wic::FormatConverter> GetWICBitmapSource() {return m_pWICBitmapSource;}

    // Overrides
public:
    virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
    virtual void DeleteContents();

    // Implementation
private:
    BOOL _LoadBitmapSourceFromFile(LPCTSTR pszFileName);
// ...
};

// DemoImageViewerDoc.h

// ...

class CDemoImageViewerDoc : public CDocument

{

// Attributes

private:

std::shared_ptr<ns::wic::FormatConverter> m_pWICBitmapSource;

// Operations

public:

std::shared_ptr<ns::wic::FormatConverter> GetWICBitmapSource() {return m_pWICBitmapSource;}

// Overrides

public:

virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);

virtual void DeleteContents();

// Implementation

private:

BOOL _LoadBitmapSourceFromFile(LPCTSTR pszFileName);

// ...

};

// DemoImageViewerDoc.cpp
// ...
BOOL CDemoImageViewerDoc::OnOpenDocument(LPCTSTR lpszPathName)
{
    if (!CDocument::OnOpenDocument(lpszPathName))
        return FALSE;

    return _LoadBitmapSourceFromFile(lpszPathName);
}

void CDemoImageViewerDoc::DeleteContents()
{
    m_pWICBitmapSource.reset();

    CDocument::DeleteContents();
}

BOOL CDemoImageViewerDoc::_LoadBitmapSourceFromFile(LPCTSTR pszFileName)
{
    BOOL bRet = FALSE;
    try
    {
        // get WIC Imaging Factory
        CDemoImageViewerApp* pApp = static_cast<CDemoImageViewerApp*>(AfxGetApp());
        std::shared_ptr pWICImagingFactory 
            = pApp->GetWICImagingFactory();

        // create BitmapDecoder from a file
        const std::shared_ptr<ns::wic::BitmapDecoder> pBitmapDecoder = 
            pWICImagingFactory->CreateDecoderFromFilename(CT2W(pszFileName));

        // get first page
        const std::shared_ptrr<ns::wic::BitmapFrameDecoder> pBitmapFrameDecoder 
            = pBitmapDecoder->GetFrame(0);

        // get and initialize a format converter  
        const std::shared_ptr<ns::wic::FormatConverter> pFormatConverter 
            = pWICImagingFactory->CreateFormatConverter();
        pFormatConverter->Initialize(pBitmapFrameDecoder);

        m_pWICBitmapSource = pFormatConverter;
        bRet = TRUE; // success
    }
    catch(CAtlException& e)
    {
        CString strErrMsg;
        strErrMsg.Format(_T("Open bitmap source failed\nError code: 0x%08X"), e.m_hr);
        AfxMessageBox(strErrMsg, MB_ICONERROR);
        DeleteContents();
    }
    return bRet;
}
// ...

// DemoImageViewerDoc.cpp

// ...

BOOL CDemoImageViewerDoc::OnOpenDocument(LPCTSTR lpszPathName)

{

if (!CDocument::OnOpenDocument(lpszPathName))

return FALSE;

return _LoadBitmapSourceFromFile(lpszPathName);

}

void CDemoImageViewerDoc::DeleteContents()

{

m_pWICBitmapSource.reset();

CDocument::DeleteContents();

}

BOOL CDemoImageViewerDoc::_LoadBitmapSourceFromFile(LPCTSTR pszFileName)

{

BOOL bRet = FALSE;

try

{

// get WIC Imaging Factory

CDemoImageViewerApp* pApp = static_cast<CDemoImageViewerApp*>(AfxGetApp());

std::shared_ptr pWICImagingFactory

= pApp->GetWICImagingFactory();

// create BitmapDecoder from a file

const std::shared_ptr<ns::wic::BitmapDecoder> pBitmapDecoder =

pWICImagingFactory->CreateDecoderFromFilename(CT2W(pszFileName));

// get first page

const std::shared_ptrr<ns::wic::BitmapFrameDecoder> pBitmapFrameDecoder

= pBitmapDecoder->GetFrame(0);

// get and initialize a format converter

const std::shared_ptr<ns::wic::FormatConverter> pFormatConverter

= pWICImagingFactory->CreateFormatConverter();

pFormatConverter->Initialize(pBitmapFrameDecoder);

m_pWICBitmapSource = pFormatConverter;

bRet = TRUE; // success

}

catch(CAtlException& e)

{

CString strErrMsg;

strErrMsg.Format(_T("Open bitmap source failed\nError code: 0x%08X"), e.m_hr);

AfxMessageBox(strErrMsg, MB_ICONERROR);

DeleteContents();

}

return bRet;

}

// ...

Now we have a WIC bitmap source in the document class that will be used in the view class to create a Direct2D bitmap and render it in the view’s window.

Add Direct2D render target and bitmap to the view class

// DemoImageViewerView.h
// ...
class CDemoImageViewerView : public CScrollView
{
// Attributes
private:
    std::shared_ptr<ns::d2d1::HwndRenderTarget> m_pD2DRenderTarget;
    std::shared_ptr<ns::d2d1::Bitmap> m_pD2DBitmap;

// Implementation
private:
    bool _CreateDirect2DRenderTarget(); 
    void _Resize2DRenderTarget(int cx, int cy);
    bool _CreateDirect2DBitmapFromWICBitmap();
    void _RenderD2DBitmap(CDC* pDC);
//...
};

// DemoImageViewerView.h

// ...

class CDemoImageViewerView : public CScrollView

{

// Attributes

private:

std::shared_ptr<ns::d2d1::HwndRenderTarget> m_pD2DRenderTarget;

std::shared_ptr<ns::d2d1::Bitmap> m_pD2DBitmap;

// Implementation

private:

bool _CreateDirect2DRenderTarget();

void _Resize2DRenderTarget(int cx, int cy);

bool _CreateDirect2DBitmapFromWICBitmap();

void _RenderD2DBitmap(CDC* pDC);

//...

};

Create a Direct2D render target for the view window.

bool CDemoImageViewerView::_CreateDirect2DRenderTarget()
{
    bool bRet = false;
    try
    {
        // reset the window render target
        m_pD2DRenderTarget.reset();

        // get Direct2D factory
        CDemoImageViewerApp* pApp = static_cast<CDemoImageViewerApp*>(AfxGetApp());
        std::shared_ptr<ns::d2d1::Factory> pDirect2DFactory = pApp->GetDirect2DFactory();

        // create a render target for this window
        // intial size is zero; will be resized in WM_SIZE message handler
        m_pD2DRenderTarget = pDirect2DFactory->CreateHwndRenderTarget(m_hWnd, 0, 0);

        bRet = true; // success
    }
    catch(CAtlException& e)
    {
        CString strError; // show what's going wrong
        strError.Format(_T("Create render target failed.\nError code: 0x%08X"), e.m_hr);
        AfxMessageBox(strError);
    }
    return bRet;
}

bool CDemoImageViewerView::_CreateDirect2DRenderTarget()

{

bool bRet = false;

try

{

// reset the window render target

m_pD2DRenderTarget.reset();

// get Direct2D factory

CDemoImageViewerApp* pApp = static_cast<CDemoImageViewerApp*>(AfxGetApp());

std::shared_ptr<ns::d2d1::Factory> pDirect2DFactory = pApp->GetDirect2DFactory();

// create a render target for this window

// intial size is zero; will be resized in WM_SIZE message handler

m_pD2DRenderTarget = pDirect2DFactory->CreateHwndRenderTarget(m_hWnd, 0, 0);

bRet = true; // success

}

catch(CAtlException& e)

{

CString strError; // show what's going wrong

strError.Format(_T("Create render target failed.\nError code: 0x%08X"), e.m_hr);

AfxMessageBox(strError);

}

return bRet;

}

A good place to call _CreateDirect2DRenderTarget is in the WM_CREATE message handler.

Resize the Direct2D render target each time is necessary.

void CDemoImageViewerView::_Resize2DRenderTarget(int cx, int cy)
{
    if(nullptr != m_pD2DRenderTarget)
    {
        try
        {
            ns::d2d1::SIZE_U sizeTarget = {cx, cy};
            m_pD2DRenderTarget->Resize(sizeTarget);
        }
        catch(CAtlException& e)
        {
            HRESULT hr = e.m_hr; // just catch it
        }
    }
}

void CDemoImageViewerView::_Resize2DRenderTarget(int cx, int cy)

{

if(nullptr != m_pD2DRenderTarget)

{

try

{

ns::d2d1::SIZE_U sizeTarget = {cx, cy};

m_pD2DRenderTarget->Resize(sizeTarget);

}

catch(CAtlException& e)

{

HRESULT hr = e.m_hr; // just catch it

}

If the render target must fit the view window, then the place to call _Resize2DRenderTarget is the WM_SIZE mesage handler.

Create the Direct2D bitmap from WIC bitmap.

bool CDemoImageViewerView::_CreateDirect2DBitmapFromWICBitmap()
{
    bool bRet = false;
    try
    {
        // reset the Direct2D bitmap
        m_pD2DBitmap.reset();

        // get WIC bitmap source from document class
        CDemoImageViewerDoc* pDoc = GetDocument();
        std::shared_ptr pWICBitmapSource = pDoc->GetWICBitmapSource();

        if(nullptr != pWICBitmapSource)
        {
            // get Direct2D factory
            CDemoImageViewerApp* pApp = static_cast<CDemoImageViewerApp*>(AfxGetApp());
            std::shared_ptr<ns::d2d1::Factory> pDirect2DFactory = pApp->GetDirect2DFactory();

            // create Direct2D bitmap from WIC bitmap 
            std::shared_ptr<ns::wic::FormatConverter> pWICBitmapSource = pDoc->GetWICBitmapSource();
            m_pD2DBitmap = m_pD2DRenderTarget->CreateBitmapFromWicBitmap(pWICBitmapSource);

            bRet = true; // success
        }
    }
    catch(CAtlException& e)
    {
        CString strError; // show what's going wrong
        strError.Format(_T("Create Direct2D bitmap from WIC bitmap failed.")
            _T("\nError code: 0x%08X"), e.m_hr);
        AfxMessageBox(strError);
    }
    return bRet;
}

bool CDemoImageViewerView::_CreateDirect2DBitmapFromWICBitmap()

{

bool bRet = false;

try

{

// reset the Direct2D bitmap

m_pD2DBitmap.reset();

// get WIC bitmap source from document class

CDemoImageViewerDoc* pDoc = GetDocument();

std::shared_ptr pWICBitmapSource = pDoc->GetWICBitmapSource();

if(nullptr != pWICBitmapSource)

{

// get Direct2D factory

CDemoImageViewerApp* pApp = static_cast<CDemoImageViewerApp*>(AfxGetApp());

std::shared_ptr<ns::d2d1::Factory> pDirect2DFactory = pApp->GetDirect2DFactory();

// create Direct2D bitmap from WIC bitmap

std::shared_ptr<ns::wic::FormatConverter> pWICBitmapSource = pDoc->GetWICBitmapSource();

m_pD2DBitmap = m_pD2DRenderTarget->CreateBitmapFromWicBitmap(pWICBitmapSource);

bRet = true; // success

}

catch(CAtlException& e)

{

CString strError; // show what's going wrong

strError.Format(_T("Create Direct2D bitmap from WIC bitmap failed.")

_T("\nError code: 0x%08X"), e.m_hr);

AfxMessageBox(strError);

}

return bRet;

}

In our case, the best place to call _CreateDirect2DBitmapFromWICBitmap is the overridden CView::OnUpdate function.

Finally, render the bitmap.

void CDemoImageViewerView::_RenderD2DBitmap(CDC* pDC)
{
    try
    {
        m_pD2DRenderTarget->BeginDraw();

        // clear target background using white color
        ns::d2d1::COLOR_F color = {1.f, 1.f, 1.f, 1.f}; // r, g, b, a
        m_pD2DRenderTarget->Clear(color);

        if(nullptr != m_pD2DBitmap)
        {
            ns::d2d1::SIZE_F sizeBitmap = m_pD2DBitmap->GetSize();

            CPoint point = this->GetScrollPosition();
            m_pD2DRenderTarget->SetTranslationTransform((float)-point.x, (float)-point.y);
            ns::d2d1::RECT_F rcTarget = {0, 0, sizeBitmap.width, sizeBitmap.height};
            m_pD2DRenderTarget->DrawBitmap(rcTarget, m_pD2DBitmap);
        }

        m_pD2DRenderTarget->EndDraw();
    }
    catch(CAtlException& e)
    {
        CRect rcClip;
        pDC->GetClipBox(rcClip);
        pDC->FillSolidRect(rcClip, RGB(255, 255, 255));
        CString strError; // display what's going wrong
        strError.Format(_T("Drawing bitmap failed. Error code: 0x%08X"), e.m_hr);
        pDC->TextOut(10, 10, strError);
    }
}

void CDemoImageViewerView::_RenderD2DBitmap(CDC* pDC)

{

try

{

m_pD2DRenderTarget->BeginDraw();

// clear target background using white color

ns::d2d1::COLOR_F color = {1.f, 1.f, 1.f, 1.f}; // r, g, b, a

m_pD2DRenderTarget->Clear(color);

if(nullptr != m_pD2DBitmap)

{

ns::d2d1::SIZE_F sizeBitmap = m_pD2DBitmap->GetSize();

CPoint point = this->GetScrollPosition();

m_pD2DRenderTarget->SetTranslationTransform((float)-point.x, (float)-point.y);

ns::d2d1::RECT_F rcTarget = {0, 0, sizeBitmap.width, sizeBitmap.height};

m_pD2DRenderTarget->DrawBitmap(rcTarget, m_pD2DBitmap);

}

m_pD2DRenderTarget->EndDraw();

}

catch(CAtlException& e)

{

CRect rcClip;

pDC->GetClipBox(rcClip);

pDC->FillSolidRect(rcClip, RGB(255, 255, 255));

CString strError; // display what's going wrong

strError.Format(_T("Drawing bitmap failed. Error code: 0x%08X"), e.m_hr);

pDC->TextOut(10, 10, strError);

}

Of course, in a class derived from CView, the place for calling _RenderD2DBitmap is the overridden CView::OnDraw virtual function.

Remains just few little things to ajust: handle WM_ERASEBKGND and override CScrollView::OnScrollBy. Anyway, you can find all the implementation details in the attached demo application.

Demo application

The demo application is a basic image file viewer that uses WIC Wrapper Library.
Download: WIC Wrapper Library v2_0 and Image Viewer Demo Project.zip (2181) (full WIC Wrapper Library source code is included).

Demo Image Viewer

Requirements

Platform SDK: Windows Software Development Kit (SDK) for Windows 7 or newer.
Target system:
- Windows 7, Windows Vista with Service Pack 2 and later;
- Windows Server 2008 R2, Windows Server 2008 with Service Pack 2 and later.

Resources, related articles, examples and projects

MSDN: Windows Imaging Component
MSDN: Direct2D
MSDN: WIC Image Viewer Using Direct2D Sample
MSDN Archive: WIC Windows 7 Samples
Codeproject: Windows Development in C++, COM API clients
CodePlex: harlinn::windows – A C++ library targeting Windows 7 and above

WIC File Open Dialog Using IFileOpenDialog Interface

1 Reply

A previoius article extends CFileDialog MFC class, in order to make a File Open or a File Save dialog that automatically filters files, according to available WIC (Windows Imaging Component) codecs. This article presents how to show a similar File Open dialog using IFileOpenDialog interface. This way, it can be used not only in an aplication that uses MFC, but also in an ATL one, even in a raw Win32 or console application that uses basic ATL stuff.
Let’s see an example.

Using IFileOpenDialog to show a WIC File Open Dialog

HRESULT ShowWICFileOpenDialog(HWND hWndOwner, CStringW& strFile)
{

    // create IFileOpenDialog instance.
    CComPtr<IFileOpenDialog> pIFileOpenDialog;
    HRESULT hr = pIFileOpenDialog.CoCreateInstance(CLSID_FileOpenDialog);

    // get an array of WIC decoders friendly names and extensions
    COMDLG_FILTERSPEC* pFilterSpecArray = NULL;
    UINT cbFilterSpecCount = 0;
    if(SUCCEEDED(hr))
    {
        hr = GetWICFileOpenDialogFilterSpecs(pFilterSpecArray, cbFilterSpecCount);
    }

    // set the filter
    if(SUCCEEDED(hr))
    {
        hr = pIFileOpenDialog->SetFileTypes(cbFilterSpecCount, pFilterSpecArray);
    }

    // show the file open dialog, and get the chosen file
    if(SUCCEEDED(hr))
    {
        hr = pIFileOpenDialog->Show(hWndOwner);
    }

    // get the choosen full path and file name
    if(SUCCEEDED(hr))
    {
        CComPtr<IShellItem> pIShellItem;
        hr = pIFileOpenDialog->GetResult(&pIShellItem);
        if(SUCCEEDED(hr))
        {
            LPWSTR pszName = NULL;
            hr = pIShellItem->GetDisplayName(SIGDN_FILESYSPATH, &pszName);
            strFile = pszName;
            CoTaskMemFree(pszName); 
        }
    }

    // do cleanup
    for(UINT nIndex = 0; nIndex < cbFilterSpecCount; nIndex++)
    {
        delete []pFilterSpecArray[nIndex].pszName;
        delete []pFilterSpecArray[nIndex].pszSpec;
    }
    delete []pFilterSpecArray;

    return hr;
}

HRESULT ShowWICFileOpenDialog(HWND hWndOwner, CStringW& strFile)

{

// create IFileOpenDialog instance.

CComPtr<IFileOpenDialog> pIFileOpenDialog;

HRESULT hr = pIFileOpenDialog.CoCreateInstance(CLSID_FileOpenDialog);

// get an array of WIC decoders friendly names and extensions

COMDLG_FILTERSPEC* pFilterSpecArray = NULL;

UINT cbFilterSpecCount = 0;

if(SUCCEEDED(hr))

{

hr = GetWICFileOpenDialogFilterSpecs(pFilterSpecArray, cbFilterSpecCount);

}

// set the filter

if(SUCCEEDED(hr))

{

hr = pIFileOpenDialog->SetFileTypes(cbFilterSpecCount, pFilterSpecArray);

}

// show the file open dialog, and get the chosen file

if(SUCCEEDED(hr))

{

hr = pIFileOpenDialog->Show(hWndOwner);

}

// get the choosen full path and file name

if(SUCCEEDED(hr))

{

CComPtr<IShellItem> pIShellItem;

hr = pIFileOpenDialog->GetResult(&pIShellItem);

if(SUCCEEDED(hr))

{

LPWSTR pszName = NULL;

hr = pIShellItem->GetDisplayName(SIGDN_FILESYSPATH, &pszName);

strFile = pszName;

CoTaskMemFree(pszName);

}

// do cleanup

for(UINT nIndex = 0; nIndex < cbFilterSpecCount; nIndex++)

{

delete []pFilterSpecArray[nIndex].pszName;

delete []pFilterSpecArray[nIndex].pszSpec;

}

delete []pFilterSpecArray;

return hr;

}

Enumerating the WIC decoders

HRESULT GetWICFileOpenDialogFilterSpecs(COMDLG_FILTERSPEC*& pFilterSpecArray, UINT& cbFilterSpecCount)
{
    ATLASSERT(NULL == pFilterSpecArray);
    cbFilterSpecCount = 1; // we'll use the last one for "All WIC files" 
    CStringW strAllSpecs;

    // create IWICImagingFactory instance
    CComPtr<IWICImagingFactory> pIWICImagingFactory;
    HRESULT hr = pIWICImagingFactory.CoCreateInstance(CLSID_WICImagingFactory);

    // create WIC decoders enumerator
    CComPtr<IEnumUnknown> pIEnum;
    if(SUCCEEDED(hr))
    {
        DWORD dwOptions = WICComponentEnumerateDefault;
        hr = pIWICImagingFactory->CreateComponentEnumerator(WICDecoder, dwOptions, &pIEnum);
    }

    if(SUCCEEDED(hr))
    {
        CComPtr<IUnknown> pElement;
        ULONG cbActual = 0;
        // count enumerator elements
        while(S_OK == pIEnum->Next(1, &pElement, &cbActual))
        {
            ++cbFilterSpecCount;
            pElement = NULL;
        } 

        // alloc COMDLG_FILTERSPEC array
        pFilterSpecArray = new COMDLG_FILTERSPEC[cbFilterSpecCount];

        // reset enumaration an loop again to fill filter specs array
        pIEnum->Reset();
        COMDLG_FILTERSPEC* pFilterSpec = pFilterSpecArray;
        while(S_OK == pIEnum->Next(1, &pElement, &cbActual))
        {

            CComQIPtr<IWICBitmapDecoderInfo> pIWICBitmapDecoderInfo = pElement;
            // get necessary buffer size for friendly name and extensions
            UINT cbName = 0, cbFileExt = 0;
            pIWICBitmapDecoderInfo->GetFriendlyName(0, NULL, &cbName);
            pIWICBitmapDecoderInfo->GetFileExtensions(0, NULL, &cbFileExt);

            // get decoder friendly name
            (*pFilterSpec).pszName = new WCHAR[cbName];
            pIWICBitmapDecoderInfo->GetFriendlyName(cbName, (WCHAR*)(*pFilterSpec).pszName, &cbName);

            // get extensions; wee need to replace some characters according to the specs
            CStringW strSpec;
            pIWICBitmapDecoderInfo->GetFileExtensions(cbFileExt, CStrBuf(strSpec, cbFileExt), &cbFileExt);
            strSpec.Replace(L',', L';');
            strSpec.Replace(L".", L"*.");
            size_t size = strSpec.GetLength() + 1;
            (*pFilterSpec).pszSpec = new WCHAR[size];
            wcscpy_s((wchar_t*)(*pFilterSpec).pszSpec, size, strSpec.GetString());

            // append to "All WIC files" specs 
            strSpec += L";";
            strAllSpecs += strSpec;

            ++pFilterSpec;
            pElement = NULL;
        }

        // set "All WIC files" specs 
        strAllSpecs.TrimRight(_T(';'));
        (*pFilterSpec).pszName = new WCHAR[wcslen(L"All WIC files") + 1];
        wcscpy_s((wchar_t*)(*pFilterSpec).pszName, wcslen(L"All WIC files") + 1, L"All WIC files");
        (*pFilterSpec).pszSpec = new WCHAR[strAllSpecs.GetLength() + 1];
        wcscpy_s((wchar_t*)(*pFilterSpec).pszSpec, strAllSpecs.GetLength() + 1, strAllSpecs.GetString());
    }
    return S_OK;
}

HRESULT GetWICFileOpenDialogFilterSpecs(COMDLG_FILTERSPEC*& pFilterSpecArray, UINT& cbFilterSpecCount)

{

ATLASSERT(NULL == pFilterSpecArray);

cbFilterSpecCount = 1; // we'll use the last one for "All WIC files"

CStringW strAllSpecs;

// create IWICImagingFactory instance

CComPtr<IWICImagingFactory> pIWICImagingFactory;

HRESULT hr = pIWICImagingFactory.CoCreateInstance(CLSID_WICImagingFactory);

// create WIC decoders enumerator

CComPtr<IEnumUnknown> pIEnum;

if(SUCCEEDED(hr))

{

DWORD dwOptions = WICComponentEnumerateDefault;

hr = pIWICImagingFactory->CreateComponentEnumerator(WICDecoder, dwOptions, &pIEnum);

}

if(SUCCEEDED(hr))

{

CComPtr<IUnknown> pElement;

ULONG cbActual = 0;

// count enumerator elements

while(S_OK == pIEnum->Next(1, &pElement, &cbActual))

{

++cbFilterSpecCount;

pElement = NULL;

}

// alloc COMDLG_FILTERSPEC array

pFilterSpecArray = new COMDLG_FILTERSPEC[cbFilterSpecCount];

// reset enumaration an loop again to fill filter specs array

pIEnum->Reset();

COMDLG_FILTERSPEC* pFilterSpec = pFilterSpecArray;

while(S_OK == pIEnum->Next(1, &pElement, &cbActual))

{

CComQIPtr<IWICBitmapDecoderInfo> pIWICBitmapDecoderInfo = pElement;

// get necessary buffer size for friendly name and extensions

UINT cbName = 0, cbFileExt = 0;

pIWICBitmapDecoderInfo->GetFriendlyName(0, NULL, &cbName);

pIWICBitmapDecoderInfo->GetFileExtensions(0, NULL, &cbFileExt);

// get decoder friendly name

(*pFilterSpec).pszName = new WCHAR[cbName];

pIWICBitmapDecoderInfo->GetFriendlyName(cbName, (WCHAR*)(*pFilterSpec).pszName, &cbName);

// get extensions; wee need to replace some characters according to the specs

CStringW strSpec;

pIWICBitmapDecoderInfo->GetFileExtensions(cbFileExt, CStrBuf(strSpec, cbFileExt), &cbFileExt);

strSpec.Replace(L',', L';');

strSpec.Replace(L".", L"*.");

size_t size = strSpec.GetLength() + 1;

(*pFilterSpec).pszSpec = new WCHAR[size];

wcscpy_s((wchar_t*)(*pFilterSpec).pszSpec, size, strSpec.GetString());

// append to "All WIC files" specs

strSpec += L";";

strAllSpecs += strSpec;

++pFilterSpec;

pElement = NULL;

}

// set "All WIC files" specs

strAllSpecs.TrimRight(_T(';'));

(*pFilterSpec).pszName = new WCHAR[wcslen(L"All WIC files") + 1];

wcscpy_s((wchar_t*)(*pFilterSpec).pszName, wcslen(L"All WIC files") + 1, L"All WIC files");

(*pFilterSpec).pszSpec = new WCHAR[strAllSpecs.GetLength() + 1];

wcscpy_s((wchar_t*)(*pFilterSpec).pszSpec, strAllSpecs.GetLength() + 1, strAllSpecs.GetString());

}

return S_OK;

}

Demo project

The demo project is a simple Win32 console application that uses the above functions.

Download: WIC_File_Open_Dialog_Win32_Demo.zip (1311)

WIC File Open Dialog – Demo

// stdafx.h
// ...

// ATL
#include <atlbase.h>
#include <atlstr.h>

// Shell
#include <Shobjidl.h>

// WIC
#include <wincodec.h>
#pragma comment(lib, "Windowscodecs.lib")

// stdafx.h

// ...

// ATL

#include <atlbase.h>

#include <atlstr.h>

// Shell

#include <Shobjidl.h>

// WIC

#include <wincodec.h>

#pragma comment(lib, "Windowscodecs.lib")

// Demo.cpp
// ...

int main()
{
    // initialize COM
    HRESULT hr = ::CoInitialize(NULL); 
    if(SUCCEEDED(hr))
    {
        CStringW strFile;
        hr = ShowWICFileOpenDialog(NULL, strFile);
        if(SUCCEEDED(hr))
        {
            ::MessageBoxW(NULL, strFile, L"Demo WIC Open File Dialog", MB_OK);
        }
        // release COM
        ::CoUninitialize();
    }
    return hr;
}

// Demo.cpp

// ...

int main()

{

// initialize COM

HRESULT hr = ::CoInitialize(NULL);

if(SUCCEEDED(hr))

{

CStringW strFile;

hr = ShowWICFileOpenDialog(NULL, strFile);

if(SUCCEEDED(hr))

{

::MessageBoxW(NULL, strFile, L"Demo WIC Open File Dialog", MB_OK);

}

// release COM

::CoUninitialize();

}

return hr;

}

Notes

In a similar way, we can make a File Save dialog using IFileSaveDialog interface.
This article presents just proof of concepts. IFileOpenDialog offers much more methods to customize the dialog according to specific needs. And of course, a more elegant job can be done by writing some C++ wrapper class(es).
For the future, I intend to integrate WIC File Dialogs in WIC Wrapper Library also presented in this blog.
The built-in WIC decoders deal with the following image file formats: BMP, GIF, ICO, JPEG, PNG, TIFF and WMPhoto. However there are many other decoders that can befound over the internet. Just to mention two free ones: Microsoft Camera Codec Pack and Adobe DNG Codec for Windows.

Resources

Free WIC codecs download

WIC Wrapper Library – Version 1.1

1 Reply

WIC Wrapper Library v1.1 has the following:

new and completed methods for existing wrapper classes in the previous version;
new classes: wic::Bitmap and wic::Palette;
a new header containg enums, WicWrapEnums.h.

Download: WIC Wrapper Library [1.1].zip (1343)

Example 2: Using wic::ImagingFactory::CreateBitmapFromHICON and wic::Bitmap

The following example is close to the previous one, except that it uses wic::ImagingFactory::CreateBitmapFromHICON to display an icon resource.

BOOL CDemoDoc::OnNewDocument()
{
    BOOL bRet = FALSE;
    if(!CDocument::OnNewDocument())
        return bRet;

    try
    {   
        // get ImagingFactory instance
        const std::shared_ptr<wic::ImagingFactory> pImagingFactory 
            = wic::ImagingFactory::GetInstance();

        // create wic::Bitmap object from an icon resource
        HICON hIcon = (HICON)::LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_DEMO_ICON), IMAGE_ICON,  
            256, 256, LR_DEFAULTCOLOR);
        std::shared_ptr<wic::Bitmap> pBitmap = pImagingFactory->CreateBitmapFromHICON(hIcon);

        // get and initialize a format converter  
        const std::shared_ptr<wic::FormatConverter> pFormatConverter 
            = pImagingFactory->CreateFormatConverter();
        pFormatConverter->Initialize(pBitmap);

        // calculate stride and necessary buffer size
        const CSize size = pBitmap->GetSize();
        const UINT cbStride = 4 * size.cx;
        const UINT cbBufferSize = cbStride * size.cy;

        // allocate buffer then copy pixels
        m_pBitmapBuffer = new BYTE[cbBufferSize];
        pFormatConverter->CopyPixels(CRect(0, 0, size.cx, size.cy), 
            cbStride, cbBufferSize, m_pBitmapBuffer);

        // create a Gdiplus::Bitmap object
        m_pBitmap = new Gdiplus::Bitmap(size.cx, size.cy, cbStride, 
            PixelFormat32bppARGB, m_pBitmapBuffer);
        if(Gdiplus::Ok != m_pBitmap->GetLastStatus())
        {
            throw(CAtlException(E_FAIL));
        }
        bRet = TRUE; // success
    }
    catch(CAtlException& e)
    {
        CString strErrMsg;
        strErrMsg.Format(_T("Error 0x%08X"), e.m_hr);
        AfxMessageBox(strErrMsg, MB_ICONERROR);
        DeleteContents();
    }

    return bRet;
}

BOOL CDemoDoc::OnNewDocument()

{

BOOL bRet = FALSE;

if(!CDocument::OnNewDocument())

return bRet;

try

{

// get ImagingFactory instance

const std::shared_ptr<wic::ImagingFactory> pImagingFactory

= wic::ImagingFactory::GetInstance();

// create wic::Bitmap object from an icon resource

HICON hIcon = (HICON)::LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_DEMO_ICON), IMAGE_ICON,

256, 256, LR_DEFAULTCOLOR);

std::shared_ptr<wic::Bitmap> pBitmap = pImagingFactory->CreateBitmapFromHICON(hIcon);

// get and initialize a format converter

const std::shared_ptr<wic::FormatConverter> pFormatConverter

= pImagingFactory->CreateFormatConverter();

pFormatConverter->Initialize(pBitmap);

// calculate stride and necessary buffer size

const CSize size = pBitmap->GetSize();

const UINT cbStride = 4 * size.cx;

const UINT cbBufferSize = cbStride * size.cy;

// allocate buffer then copy pixels

m_pBitmapBuffer = new BYTE[cbBufferSize];

pFormatConverter->CopyPixels(CRect(0, 0, size.cx, size.cy),

cbStride, cbBufferSize, m_pBitmapBuffer);

// create a Gdiplus::Bitmap object

m_pBitmap = new Gdiplus::Bitmap(size.cx, size.cy, cbStride,

PixelFormat32bppARGB, m_pBitmapBuffer);

if(Gdiplus::Ok != m_pBitmap->GetLastStatus())

{

throw(CAtlException(E_FAIL));

}

bRet = TRUE; // success

}

catch(CAtlException& e)

{

CString strErrMsg;

strErrMsg.Format(_T("Error 0x%08X"), e.m_hr);

AfxMessageBox(strErrMsg, MB_ICONERROR);

DeleteContents();

}

return bRet;

}

Demo Application

The demo application displays an icon resource when no image file is loaded.

Download: WIC Wrapper Library Sample [1.1].zip (1254)

WIC Wrapper Library – Sample Application #2

WIC Wrapper Library – Version 1.0

1 Reply

I’ve begun writing a series of wrapper classes over WIC (Windows Imaging Component) interfaces, that can easily be used in MFC, ATL, or Win32 applications without worry about directly dealing with COM interfaces.
This first version contains basic operation for loading, scaling and converting source image formats that are supported by WIC.
Download: WIC Wrapper Library.zip (1081)
WIC Wrapper Library.zip archive contains the following:

Header files, located in \WicWrap\Include folder;
WicWrapDLL.dll, both Debug and Release builds, located in \WicWrap\Bin folder;
WicWrapDLL.lib, both Debug and Release builds, located in \WicWrap\Lib folder.

Adding WIC Wrapper Library to a project

As said before, WIC Wrapper Library can be used in MFC, ATL or Win32 projects. Here is an example shownig the steps for adding this library to an existing project:

copy WicWrap folder, in the solution directory;
in Solution Explorer window right-click on project name and choose the Properties menu item;
choose All Configurations, go to Configuration Properties\C/C++ and add $(SolutionDir)WicWrap\Include in the Additional Include Directories field;
go to Configuration Properties\Linker\Input and add WicWrapDLL.lib (also for all configurations);
choose Debug configuration, go to Configuration Properties\Linker and add $(SolutionDir)WicWrap\Lib\Debug in the Additional Library Directories field;
choose Release configuration, go to Configuration Properties\Linker and add $(SolutionDir)WicWrap\Lib\Release in the Additional Library Directories field
copy the debug and release versions of WicWrapDLL.dll in solution Debug and Release output directories;
in Solution Explorer window, right-click on project name, choose Add\Existing Item and add the WicWrap header files from \WicWrap\Include folder;
include WicWrap.h in the project source code, e.g in stdafx.h .

Using WIC Wrapper Library

Next is a simple example, in an MFC program:

BOOL CDemoDoc::OnOpenDocument(LPCTSTR lpszPathName)
{
    BOOL bRet = FALSE;
    if(!CDocument::OnOpenDocument(lpszPathName))
        return bRet;

    try
    {
        // get ImagingFactory instance
        const std::shared_ptr<wic::ImagingFactory> pImagingFactory 
            = wic::ImagingFactory::GetInstance();

        // create BitmapDecoder from a file
        const std::shared_ptr<wic::BitmapDecoder> pBitmapDecoder = 
            pImagingFactory->CreateDecoderFromFilename(CT2W(lpszPathName));

        // get first frame
        const std::shared_ptr<wic::BitmapFrameDecoder> pBitmapFrameDecoder 
            = pBitmapDecoder->GetFrame(0);

        // get and initialize a format converter  
        const std::shared_ptr<wic::FormatConverter> pFormatConverter 
            = pImagingFactory->CreateFormatConverter();
        pFormatConverter->Initialize(pBitmapFrameDecoder);

        // calculate stride and necessary buffer size
        const CSize size = pBitmapFrameDecoder->GetSize();
        const UINT cbStride = 4 * size.cx;
        const UINT cbBufferSize = cbStride * size.cy;

        // allocate buffer then copy pixels
        m_pBitmapBuffer = new BYTE[cbBufferSize];
        pFormatConverter->CopyPixels(CRect(0, 0, size.cx, size.cy), 
            cbStride, cbBufferSize, m_pBitmapBuffer);

        // creat a Gdiplus::Bitmap object
        m_pBitmap = new Gdiplus::Bitmap(size.cx, size.cy, cbStride, 
            PixelFormat32bppARGB, m_pBitmapBuffer);
        if(Gdiplus::Ok != m_pBitmap->GetLastStatus())
        {
            AtlThrow(E_FAIL);
        }
        bRet = TRUE; // success
    }
    catch(CAtlException& e)
    {
        CString strErrMsg;
        strErrMsg.Format(_T("Error 0x%08X"), e.m_hr);
        AfxMessageBox(strErrMsg, MB_ICONERROR);
        DeleteContents();
    }
    return bRet;
}

BOOL CDemoDoc::OnOpenDocument(LPCTSTR lpszPathName)

{

BOOL bRet = FALSE;

if(!CDocument::OnOpenDocument(lpszPathName))

return bRet;

try

{

// get ImagingFactory instance

const std::shared_ptr<wic::ImagingFactory> pImagingFactory

= wic::ImagingFactory::GetInstance();

// create BitmapDecoder from a file

const std::shared_ptr<wic::BitmapDecoder> pBitmapDecoder =

pImagingFactory->CreateDecoderFromFilename(CT2W(lpszPathName));

// get first frame

const std::shared_ptr<wic::BitmapFrameDecoder> pBitmapFrameDecoder

= pBitmapDecoder->GetFrame(0);

// get and initialize a format converter

const std::shared_ptr<wic::FormatConverter> pFormatConverter

= pImagingFactory->CreateFormatConverter();

pFormatConverter->Initialize(pBitmapFrameDecoder);

// calculate stride and necessary buffer size

const CSize size = pBitmapFrameDecoder->GetSize();

const UINT cbStride = 4 * size.cx;

const UINT cbBufferSize = cbStride * size.cy;

// allocate buffer then copy pixels

m_pBitmapBuffer = new BYTE[cbBufferSize];

pFormatConverter->CopyPixels(CRect(0, 0, size.cx, size.cy),

cbStride, cbBufferSize, m_pBitmapBuffer);

// creat a Gdiplus::Bitmap object

m_pBitmap = new Gdiplus::Bitmap(size.cx, size.cy, cbStride,

PixelFormat32bppARGB, m_pBitmapBuffer);

if(Gdiplus::Ok != m_pBitmap->GetLastStatus())

{

AtlThrow(E_FAIL);

}

bRet = TRUE; // success

}

catch(CAtlException& e)

{

CString strErrMsg;

strErrMsg.Format(_T("Error 0x%08X"), e.m_hr);

AfxMessageBox(strErrMsg, MB_ICONERROR);

DeleteContents();

}

return bRet;

}

More details can be found in the demo application, attached below.

Demo Application

The demo application is a simple image viewer made in a simple SDI MFC project.
Download: WIC Wrapper Library Sample [1].zip (1409)

WIC Wrapper Library – Sample Application

Note: the image shown in the sample application is taken from SoftIcons.com site.

WIC-related articles and resources

Codexpert Blog: WIC Topics
Marc Gregoire’s Blog: How to use WIC to load an image, and draw it with tranparency using only GDI
MSDN: Windows Imaging Component

Create and use a WIC bitmap render target

Replace CWnd::EnableD2DSupport

Demo application

Resources and related articles

Share this:

Like this:

CComponentEnumT – a template class for enumerating WIC components

CComponentInfoBaseT – base class for all other component info classes

CPixelFormatInfoT – just one of classes getting WIC component info

CComponentEnumT specializations and aliases

Enumerating WIC pixel formats

Get the pixel format info

Demo solution

Notes

Resources and related articles

Share this:

Like this:

Reading IFD and EXIF metadata from a JPEG file

Reading IFD and EXIF metadata from an image file

References and related articles

Share this:

Like this:

Let’s see the code, step by step!

Demo application

Requirements

Resources, related articles, examples and projects

Share this:

Like this:

Using IFileOpenDialog to show a WIC File Open Dialog

Enumerating the WIC decoders

Demo project

Notes

Resources

Free WIC codecs download

See also

Share this:

Like this:

Example 2: Using wic::ImagingFactory::CreateBitmapFromHICON and wic::Bitmap

Demo Application

See also

Share this:

Like this:

Adding WIC Wrapper Library to a project

Using WIC Wrapper Library

Demo Application

WIC-related articles and resources

Share this:

Like this: