Tag Archives: wic codecs

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 (880)

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

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

MFC-extension WIC File Dialogs

CWICFileDialog class

CWICFileDialog is derived from CFileDialog MFC class. It basically overrides CFileDialog::DoModal and constructs the file types filter.

INT_PTR CWICFileDialog::DoModal()
{
   // Get a list of available decoders or encoders 
   // for File Open or File Save As dialog, respectively
   WICComponentType type = m_bOpenFileDialog ? WICDecoder : WICEncoder;
   CodecsInfoList list;
   VERIFY(SUCCEEDED(_FillCodecsInfoList(type, list)));

   // Constructs MFC-style filter (using '|' as separator.
   _ConstructMFCStyleFilter(list);

   // translate MFC-style filter into WinAPI-style filter (using '\0' as separator). 
   _TranslateFilter();

   // clear the codecs info list
   _ClearCodecsInfoList(list);

   // call base class method
   return CFileDialog::DoModal();
}

INT_PTR CWICFileDialog::DoModal()

{

// Get a list of available decoders or encoders

// for File Open or File Save As dialog, respectively

WICComponentType type = m_bOpenFileDialog ? WICDecoder : WICEncoder;

CodecsInfoList list;

VERIFY(SUCCEEDED(_FillCodecsInfoList(type, list)));

// Constructs MFC-style filter (using '|' as separator.

_ConstructMFCStyleFilter(list);

// translate MFC-style filter into WinAPI-style filter (using '\0' as separator).

_TranslateFilter();

// clear the codecs info list

_ClearCodecsInfoList(list);

// call base class method

return CFileDialog::DoModal();

}

For implementation details, download the demo project attached here.

Demo project

The demo project is just a simple dialog-based MFC application that uses CWICFileDialog. It does nothing else but only shows the file dialogs.
Of course, in practice, you can use CWICFileDialog class in more complex applications like image file viewers, image file converters, and so on.

Resources

MSDN Library: CFileDialog Class
Windows Dev Center: Windows Imaging Component

Downloads

WIC File Dialogs - Demo Project (1477)

How to enumerate WIC codecs?

3 Replies

As shown in the previous article, Windows Imaging Component (WIC) comes with built-in codecs (for BMP, JPEG, GIF, PNG, TIFF, and HDPhoto image file formats). Additionally, WIC can deal with other image formats for which appropriate codecs are installed in the system.
Basically, to list available WIC codecs and eventually get info for each one, we can do the following:

Call IWICImagingFactory::CreateComponentEnumerator in order to get a component enumerator either for WIC decoders or for WIC encoders.
For each element of the enumerator, get IWICBitmapCodecInfo interface.
Call IWICBitmapCodecInfo::GetFriendlyName, IWICBitmapCodecInfo::GetFileExtensions and other methods in order to get codec info.

Enumerate WIC codecs

Here is a sample function, implemented as described above. First argument is a pointer to a IWICImagingFactory instance, required for creating the component enumerator. Second argument can have either WICDecoder or WICEncoder value, to retrieve WIC decoders or encoders, respectively. Finally, last argument is an ATL list containing structures to be filled with codecs info.

HRESULT CWICUtils::_EnumCodecs(IWICImagingFactory* pImagingFactory,
                               WICComponentType type,
                               CAtlList<CCodecInfo>& listCodecInfo)
{
   ATLASSERT(pImagingFactory);
   ATLASSERT((type == WICDecoder) || (type == WICEncoder));
   listCodecInfo.RemoveAll();

   CComPtr<IEnumUnknown> pEnum;
   DWORD dwOptions = WICComponentEnumerateDefault;
   HRESULT hr = pImagingFactory->CreateComponentEnumerator(type, 
      dwOptions, &pEnum);
   if(SUCCEEDED(hr))
   {
      const UINT cbBuffer = 256; // if not enough will be truncated
      ULONG cbActual = 0;
      CComPtr<IUnknown> pElement = NULL;
      while(S_OK == pEnum->Next(1, &pElement, &cbActual))
      {
         CCodecInfo codecInfo;
         UINT cbActual = 0;
         CComQIPtr<IWICBitmapCodecInfo> pCodecInfo = pElement;
         // Codec name
         pCodecInfo->GetFriendlyName(cbBuffer, 
            codecInfo.m_strFriendlyName.GetBufferSetLength(cbBuffer), 
            &cbActual);
         codecInfo.m_strFriendlyName.ReleaseBufferSetLength(cbActual);
         // File extensions
         pCodecInfo->GetFileExtensions(cbBuffer, 
            codecInfo.m_strFileExtensions.GetBufferSetLength(cbBuffer),
            &cbActual);
         codecInfo.m_strFileExtensions.ReleaseBufferSetLength(cbActual);
         //... other codec info.
         // add element to list
         listCodecInfo.AddTail(codecInfo);
         pElement = NULL;
      }
   }
   return hr;
}

HRESULT CWICUtils::_EnumCodecs(IWICImagingFactory* pImagingFactory,

WICComponentType type,

CAtlList<CCodecInfo>& listCodecInfo)

{

ATLASSERT(pImagingFactory);

ATLASSERT((type == WICDecoder) || (type == WICEncoder));

listCodecInfo.RemoveAll();

CComPtr<IEnumUnknown> pEnum;

DWORD dwOptions = WICComponentEnumerateDefault;

HRESULT hr = pImagingFactory->CreateComponentEnumerator(type,

dwOptions, &pEnum);

if(SUCCEEDED(hr))

{

const UINT cbBuffer = 256; // if not enough will be truncated

ULONG cbActual = 0;

CComPtr<IUnknown> pElement = NULL;

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

{

CCodecInfo codecInfo;

UINT cbActual = 0;

CComQIPtr<IWICBitmapCodecInfo> pCodecInfo = pElement;

// Codec name

pCodecInfo->GetFriendlyName(cbBuffer,

codecInfo.m_strFriendlyName.GetBufferSetLength(cbBuffer),

&cbActual);

codecInfo.m_strFriendlyName.ReleaseBufferSetLength(cbActual);

// File extensions

pCodecInfo->GetFileExtensions(cbBuffer,

codecInfo.m_strFileExtensions.GetBufferSetLength(cbBuffer),

&cbActual);

codecInfo.m_strFileExtensions.ReleaseBufferSetLength(cbActual);

//... other codec info.

// add element to list

listCodecInfo.AddTail(codecInfo);

pElement = NULL;

}

return hr;

}

Enumerate WIC decoders

CWICUtils::EnumDecoders simply calls CWICUtils::_EnumCodecs passing WICDecoder value.

HRESULT CWICUtils::EnumDecoders(IWICImagingFactory* pImagingFactory,
                                CAtlList<CCodecInfo>& listCodecInfo)
{
   return _EnumCodecs(pImagingFactory, WICDecoder, listCodecInfo);
}

HRESULT CWICUtils::EnumDecoders(IWICImagingFactory* pImagingFactory,

CAtlList<CCodecInfo>& listCodecInfo)

{

return _EnumCodecs(pImagingFactory, WICDecoder, listCodecInfo);

}

Enumerate WIC encoders

CWICUtils::EnumEncoders calls CWICUtils::_EnumCodecs passing WICEncoder value.

HRESULT CWICUtils::EnumEncoders(IWICImagingFactory* pImagingFactory,
                                CAtlList<CCodecInfo>& listCodecInfo)
{
   return _EnumCodecs(pImagingFactory, WICEncoder, listCodecInfo);
}

HRESULT CWICUtils::EnumEncoders(IWICImagingFactory* pImagingFactory,

CAtlList<CCodecInfo>& listCodecInfo)

{

return _EnumCodecs(pImagingFactory, WICEncoder, listCodecInfo);

}

Display WIC decoders info example

This example demonstrates how to use CWICUtils::EnumDecoders to display WIC decoders info in a simple console application.

int main()
{
   // initialize COM
   ::CoInitialize(NULL); 
   IWICImagingFactory* pImagingFactory;

   // create IWICImagingFactory instance
   HRESULT hr = ::CoCreateInstance(CLSID_WICImagingFactory,
         NULL, CLSCTX_INPROC_SERVER,
         IID_PPV_ARGS(&pImagingFactory));

   if(SUCCEEDED(hr))
   {
      CAtlList<CCodecInfo> listCodecInfo;
      // enumerate decoders
      hr = CWICUtils::EnumDecoders(pImagingFactory, listCodecInfo);
      if(SUCCEEDED(hr))
      {
         POSITION pos = listCodecInfo.GetHeadPosition();
         while(NULL != pos)
         {
            // dispay decoder info
            const CCodecInfo& codecInfo = listCodecInfo.GetNext(pos);
            wprintf_s(L"\nCodec name: %s\nFile extensions: %s\n",
               codecInfo.m_strFriendlyName, 
               codecInfo.m_strFileExtensions);
         }
      }
      pImagingFactory->Release();
   }
   ::CoUninitialize();
   return hr;
}

int main()

{

// initialize COM

::CoInitialize(NULL);

IWICImagingFactory* pImagingFactory;

// create IWICImagingFactory instance

HRESULT hr = ::CoCreateInstance(CLSID_WICImagingFactory,

NULL, CLSCTX_INPROC_SERVER,

IID_PPV_ARGS(&pImagingFactory));

if(SUCCEEDED(hr))

{

CAtlList<CCodecInfo> listCodecInfo;

// enumerate decoders

hr = CWICUtils::EnumDecoders(pImagingFactory, listCodecInfo);

if(SUCCEEDED(hr))

{

POSITION pos = listCodecInfo.GetHeadPosition();

while(NULL != pos)

{

// dispay decoder info

const CCodecInfo& codecInfo = listCodecInfo.GetNext(pos);

wprintf_s(L"\nCodec name: %s\nFile extensions: %s\n",

codecInfo.m_strFriendlyName,

codecInfo.m_strFileExtensions);

}

pImagingFactory->Release();

}

::CoUninitialize();

return hr;

}

Notes

Include necessary ATL headers as well as WIC library headers.

C++

// ATL headers #include <atlbase.h> #include <atlstr.h> #include <atlcoll.h> // WIC library headers #include <Wincodec.h>

1
2
3
4
5
6

// ATL headers
#include <atlbase.h>
#include <atlstr.h>
#include <atlcoll.h>
// WIC library headers
#include <Wincodec.h>
Add Windowscodecs.lib to linker additional dependencies or use pragma comment lib as follows:

C++

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

1

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

Here are the definitions of CCodecInfo and CWICUtils classes:

struct CCodecInfo
{
   CStringW m_strFriendlyName;
   CStringW m_strFileExtensions;
   //...
};

struct CCodecInfo

{

CStringW m_strFriendlyName;

CStringW m_strFileExtensions;

//...

};

class CWICUtils
{
// ...
public:
   static HRESULT EnumDecoders(IWICImagingFactory* pImagingFactory,
                               CAtlList<CCodecInfo>& listCodecInfo);

   static HRESULT EnumEncoders(IWICImagingFactory* pImagingFactory,
                               CAtlList<CCodecInfo>>& listCodecInfo);
private:
   static HRESULT _EnumCodecs(IWICImagingFactory* pImagingFactory,
                              WICComponentType type,
                              CAtlList<CCodecInfo>>& listCodecInfo);
};

class CWICUtils

{

// ...

public:

static HRESULT EnumDecoders(IWICImagingFactory* pImagingFactory,

CAtlList<CCodecInfo>& listCodecInfo);

static HRESULT EnumEncoders(IWICImagingFactory* pImagingFactory,

CAtlList<CCodecInfo>>& listCodecInfo);

private:

static HRESULT _EnumCodecs(IWICImagingFactory* pImagingFactory,

WICComponentType type,

CAtlList<CCodecInfo>>& listCodecInfo);

};

The examples are intentionally made as simple as possible in order to just show how to do; you can modify and adapt them according to your particular needs.
I’ve tested under Visual Studio 2008.
The minimum operating system is Windows XP with SP3 or Windows XP with SP2 and redistributed WIC.

Resources

MSDN: IWICImagingFactory::CreateComponentEnumerator
MSDN: IWICComponentInfo interface
MSDN: IWICBitmapCodecInfo interface

codexpert blog

I see native code

Tag Archives: wic codecs

Enumerate WIC Components

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

Like this:

WIC File Open Dialog Using IFileOpenDialog Interface

Using IFileOpenDialog to show a WIC File Open Dialog

Enumerating the WIC decoders

Demo project

Notes

Resources

Free WIC codecs download

See also

Like this:

MFC-extension WIC File Dialogs

CWICFileDialog class

Demo project

Resources

See also

Downloads

Like this:

How to enumerate WIC codecs?

Enumerate WIC codecs

Enumerate WIC decoders

Enumerate WIC encoders

Display WIC decoders info example

Notes

Resources

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:

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:

CWICFileDialog class

Demo project

Resources

See also

Downloads

Share this:

Like this:

Enumerate WIC codecs

Enumerate WIC decoders

Enumerate WIC encoders

Display WIC decoders info example

Notes

Resources

Share this:

Like this: