Sweden-Number/dlls/windowscodecs/decoder.c

/*
 * Copyright 2020 Esme Povirk
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include <stdarg.h>

#define NONAMELESSUNION
#define COBJMACROS

#include "windef.h"
#include "winbase.h"
#include "objbase.h"

#include "wincodecs_private.h"

#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);

typedef struct {
    IWICBitmapDecoder IWICBitmapDecoder_iface;
    LONG ref;
    CRITICAL_SECTION lock; /* must be held when stream or decoder is accessed */
    IStream *stream;
    struct decoder *decoder;
    struct decoder_info decoder_info;
    struct decoder_stat file_info;
    WICDecodeOptions cache_options;
} CommonDecoder;

static inline CommonDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
{
    return CONTAINING_RECORD(iface, CommonDecoder, IWICBitmapDecoder_iface);
}

static HRESULT WINAPI CommonDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
    void **ppv)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);

    if (!ppv) return E_INVALIDARG;

    if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
    {
        *ppv = &This->IWICBitmapDecoder_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

static ULONG WINAPI CommonDecoder_AddRef(IWICBitmapDecoder *iface)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    ULONG ref = InterlockedIncrement(&This->ref);

    TRACE("(%p) refcount=%u\n", iface, ref);

    return ref;
}

static ULONG WINAPI CommonDecoder_Release(IWICBitmapDecoder *iface)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    ULONG ref = InterlockedDecrement(&This->ref);

    TRACE("(%p) refcount=%u\n", iface, ref);

    if (ref == 0)
    {
        if (This->stream)
            IStream_Release(This->stream);
        This->lock.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->lock);
        decoder_destroy(This->decoder);
        HeapFree(GetProcessHeap(), 0, This);
    }

    return ref;
}

static HRESULT WINAPI CommonDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream,
    DWORD *capability)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    HRESULT hr;

    TRACE("(%p,%p,%p)\n", iface, stream, capability);

    if (!stream || !capability) return E_INVALIDARG;

    hr = IWICBitmapDecoder_Initialize(iface, stream, WICDecodeMetadataCacheOnDemand);
    if (hr != S_OK) return hr;

    *capability = (This->file_info.flags & DECODER_FLAGS_CAPABILITY_MASK);
    return S_OK;
}

static HRESULT WINAPI CommonDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
    WICDecodeOptions cacheOptions)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    HRESULT hr=S_OK;

    TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);

    EnterCriticalSection(&This->lock);

    if (This->stream)
        hr = WINCODEC_ERR_WRONGSTATE;

    if (SUCCEEDED(hr))
        hr = decoder_initialize(This->decoder, pIStream, &This->file_info);

    if (SUCCEEDED(hr))
    {
        This->cache_options = cacheOptions;
        This->stream = pIStream;
        IStream_AddRef(This->stream);
    }

    LeaveCriticalSection(&This->lock);

    return hr;
}

static HRESULT WINAPI CommonDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
    GUID *pguidContainerFormat)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    memcpy(pguidContainerFormat, &This->decoder_info.container_format, sizeof(GUID));
    return S_OK;
}

static HRESULT WINAPI CommonDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
    IWICBitmapDecoderInfo **ppIDecoderInfo)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    TRACE("(%p,%p)\n", iface, ppIDecoderInfo);

    return get_decoder_info(&This->decoder_info.clsid, ppIDecoderInfo);
}

static HRESULT WINAPI CommonDecoder_CopyPalette(IWICBitmapDecoder *iface,
    IWICPalette *palette)
{
    TRACE("(%p,%p)\n", iface, palette);
    return WINCODEC_ERR_PALETTEUNAVAILABLE;
}

static HRESULT WINAPI CommonDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
    IWICMetadataQueryReader **reader)
{
    TRACE("(%p,%p)\n", iface, reader);

    if (!reader) return E_INVALIDARG;

    *reader = NULL;
    return WINCODEC_ERR_UNSUPPORTEDOPERATION;
}

static HRESULT WINAPI CommonDecoder_GetPreview(IWICBitmapDecoder *iface,
    IWICBitmapSource **ppIBitmapSource)
{
    TRACE("(%p,%p)\n", iface, ppIBitmapSource);

    if (!ppIBitmapSource) return E_INVALIDARG;

    *ppIBitmapSource = NULL;
    return WINCODEC_ERR_UNSUPPORTEDOPERATION;
}

static HRESULT WINAPI CommonDecoder_GetColorContexts(IWICBitmapDecoder *iface,
    UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
{
    TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);
    return WINCODEC_ERR_UNSUPPORTEDOPERATION;
}

static HRESULT WINAPI CommonDecoder_GetThumbnail(IWICBitmapDecoder *iface,
    IWICBitmapSource **ppIThumbnail)
{
    TRACE("(%p,%p)\n", iface, ppIThumbnail);

    if (!ppIThumbnail) return E_INVALIDARG;

    *ppIThumbnail = NULL;
    return WINCODEC_ERR_CODECNOTHUMBNAIL;
}

static HRESULT WINAPI CommonDecoder_GetFrameCount(IWICBitmapDecoder *iface,
    UINT *pCount)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    if (!pCount) return E_INVALIDARG;

    if (This->stream)
        *pCount = This->file_info.frame_count;
    else
        *pCount = 0;

    return S_OK;
}

static HRESULT WINAPI CommonDecoder_GetFrame(IWICBitmapDecoder *iface,
    UINT index, IWICBitmapFrameDecode **ppIBitmapFrame);

static const IWICBitmapDecoderVtbl CommonDecoder_Vtbl = {
    CommonDecoder_QueryInterface,
    CommonDecoder_AddRef,
    CommonDecoder_Release,
    CommonDecoder_QueryCapability,
    CommonDecoder_Initialize,
    CommonDecoder_GetContainerFormat,
    CommonDecoder_GetDecoderInfo,
    CommonDecoder_CopyPalette,
    CommonDecoder_GetMetadataQueryReader,
    CommonDecoder_GetPreview,
    CommonDecoder_GetColorContexts,
    CommonDecoder_GetThumbnail,
    CommonDecoder_GetFrameCount,
    CommonDecoder_GetFrame
};

typedef struct {
    IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
    IWICMetadataBlockReader IWICMetadataBlockReader_iface;
    LONG ref;
    CommonDecoder *parent;
    DWORD frame;
    struct decoder_frame decoder_frame;
    BOOL metadata_initialized;
    ULONG metadata_count;
    struct decoder_block* metadata_blocks;
} CommonDecoderFrame;

static inline CommonDecoderFrame *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
{
    return CONTAINING_RECORD(iface, CommonDecoderFrame, IWICBitmapFrameDecode_iface);
}

static inline CommonDecoderFrame *impl_from_IWICMetadataBlockReader(IWICMetadataBlockReader *iface)
{
    return CONTAINING_RECORD(iface, CommonDecoderFrame, IWICMetadataBlockReader_iface);
}

static HRESULT WINAPI CommonDecoderFrame_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
    void **ppv)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);
    if (!ppv) return E_INVALIDARG;

    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IWICBitmapSource, iid) ||
        IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
    {
        *ppv = &This->IWICBitmapFrameDecode_iface;
    }
    else if (IsEqualIID(&IID_IWICMetadataBlockReader, iid) &&
             (This->parent->file_info.flags & WICBitmapDecoderCapabilityCanEnumerateMetadata))
    {
        *ppv = &This->IWICMetadataBlockReader_iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }

    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

static ULONG WINAPI CommonDecoderFrame_AddRef(IWICBitmapFrameDecode *iface)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);
    ULONG ref = InterlockedIncrement(&This->ref);

    TRACE("(%p) refcount=%u\n", iface, ref);

    return ref;
}

static ULONG WINAPI CommonDecoderFrame_Release(IWICBitmapFrameDecode *iface)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);
    ULONG ref = InterlockedDecrement(&This->ref);

    TRACE("(%p) refcount=%u\n", iface, ref);

    if (ref == 0)
    {
        IWICBitmapDecoder_Release(&This->parent->IWICBitmapDecoder_iface);
        HeapFree(GetProcessHeap(), 0, This->metadata_blocks);
        HeapFree(GetProcessHeap(), 0, This);
    }

    return ref;
}

static HRESULT WINAPI CommonDecoderFrame_GetSize(IWICBitmapFrameDecode *iface,
    UINT *puiWidth, UINT *puiHeight)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);

    TRACE("(%p,%p,%p)\n", This, puiWidth, puiHeight);

    if (!puiWidth || !puiHeight)
        return E_POINTER;

    *puiWidth = This->decoder_frame.width;
    *puiHeight = This->decoder_frame.height;
    return S_OK;
}

static HRESULT WINAPI CommonDecoderFrame_GetPixelFormat(IWICBitmapFrameDecode *iface,
    WICPixelFormatGUID *pPixelFormat)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);

    TRACE("(%p,%p)\n", This, pPixelFormat);

    if (!pPixelFormat)
        return E_POINTER;

    *pPixelFormat = This->decoder_frame.pixel_format;
    return S_OK;
}

static HRESULT WINAPI CommonDecoderFrame_GetResolution(IWICBitmapFrameDecode *iface,
    double *pDpiX, double *pDpiY)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);

    TRACE("(%p,%p,%p)\n", This, pDpiX, pDpiY);

    if (!pDpiX || !pDpiY)
        return E_POINTER;

    *pDpiX = This->decoder_frame.dpix;
    *pDpiY = This->decoder_frame.dpiy;
    return S_OK;
}

static HRESULT WINAPI CommonDecoderFrame_CopyPalette(IWICBitmapFrameDecode *iface,
    IWICPalette *pIPalette)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);
    HRESULT hr=S_OK;

    TRACE("(%p,%p)\n", iface, pIPalette);

    if (This->decoder_frame.num_colors)
    {
        hr = IWICPalette_InitializeCustom(pIPalette, This->decoder_frame.palette, This->decoder_frame.num_colors);
    }
    else
    {
        hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
    }

    return hr;
}

static HRESULT WINAPI CommonDecoderFrame_CopyPixels(IWICBitmapFrameDecode *iface,
    const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);
    HRESULT hr;
    UINT bytesperrow;
    WICRect rect;

    TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);

    if (!pbBuffer)
        return E_POINTER;

    if (!prc)
    {
        rect.X = 0;
        rect.Y = 0;
        rect.Width = This->decoder_frame.width;
        rect.Height = This->decoder_frame.height;
        prc = &rect;
    }
    else
    {
        if (prc->X < 0 || prc->Y < 0 ||
            prc->X+prc->Width > This->decoder_frame.width ||
            prc->Y+prc->Height > This->decoder_frame.height)
            return E_INVALIDARG;
    }

    bytesperrow = ((This->decoder_frame.bpp * prc->Width)+7)/8;

    if (cbStride < bytesperrow)
        return E_INVALIDARG;

    if ((cbStride * (prc->Height-1)) + bytesperrow > cbBufferSize)
        return E_INVALIDARG;

    EnterCriticalSection(&This->parent->lock);

    hr = decoder_copy_pixels(This->parent->decoder, This->frame,
        prc, cbStride, cbBufferSize, pbBuffer);

    LeaveCriticalSection(&This->parent->lock);

    return hr;
}

static HRESULT WINAPI CommonDecoderFrame_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
    IWICMetadataQueryReader **ppIMetadataQueryReader)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);
    IWICComponentFactory* factory;
    HRESULT hr;

    TRACE("(%p,%p)\n", iface, ppIMetadataQueryReader);

    if (!ppIMetadataQueryReader)
        return E_INVALIDARG;

    if (!(This->parent->file_info.flags & WICBitmapDecoderCapabilityCanEnumerateMetadata))
        return WINCODEC_ERR_UNSUPPORTEDOPERATION;

    hr = create_instance(&CLSID_WICImagingFactory, &IID_IWICComponentFactory, (void**)&factory);

    if (SUCCEEDED(hr))
    {
        hr = IWICComponentFactory_CreateQueryReaderFromBlockReader(factory, &This->IWICMetadataBlockReader_iface, ppIMetadataQueryReader);
        IWICComponentFactory_Release(factory);
    }

    if (FAILED(hr))
        *ppIMetadataQueryReader = NULL;

    return hr;
}

static HRESULT WINAPI CommonDecoderFrame_GetColorContexts(IWICBitmapFrameDecode *iface,
    UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
{
    CommonDecoderFrame *This = impl_from_IWICBitmapFrameDecode(iface);
    HRESULT hr=S_OK;
    UINT i;
    BYTE *profile;
    DWORD profile_len;

    TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppIColorContexts, pcActualCount);

    if (!pcActualCount) return E_INVALIDARG;

    if (This->parent->file_info.flags & DECODER_FLAGS_UNSUPPORTED_COLOR_CONTEXT)
    {
        FIXME("not supported for %s\n", wine_dbgstr_guid(&This->parent->decoder_info.clsid));
        *pcActualCount = 0;
        return WINCODEC_ERR_UNSUPPORTEDOPERATION;
    }

    *pcActualCount = This->decoder_frame.num_color_contexts;

    if (This->decoder_frame.num_color_contexts && cCount && ppIColorContexts)
    {
        if (cCount >= This->decoder_frame.num_color_contexts)
        {
            EnterCriticalSection(&This->parent->lock);

            for (i=0; i<This->decoder_frame.num_color_contexts; i++)
            {
                hr = decoder_get_color_context(This->parent->decoder, This->frame, i,
                    &profile, &profile_len);
                if (SUCCEEDED(hr))
                {
                    hr = IWICColorContext_InitializeFromMemory(ppIColorContexts[i], profile, profile_len);

                    HeapFree(GetProcessHeap(), 0, profile);
                }

                if (FAILED(hr))
                    break;
            }

            LeaveCriticalSection(&This->parent->lock);
        }
        else
        {
            hr = E_INVALIDARG;
        }
    }

    return hr;
}

static HRESULT WINAPI CommonDecoderFrame_GetThumbnail(IWICBitmapFrameDecode *iface,
    IWICBitmapSource **ppIThumbnail)
{
    TRACE("(%p,%p)\n", iface, ppIThumbnail);

    if (!ppIThumbnail) return E_INVALIDARG;

    *ppIThumbnail = NULL;
    return WINCODEC_ERR_CODECNOTHUMBNAIL;
}

static const IWICBitmapFrameDecodeVtbl CommonDecoderFrameVtbl = {
    CommonDecoderFrame_QueryInterface,
    CommonDecoderFrame_AddRef,
    CommonDecoderFrame_Release,
    CommonDecoderFrame_GetSize,
    CommonDecoderFrame_GetPixelFormat,
    CommonDecoderFrame_GetResolution,
    CommonDecoderFrame_CopyPalette,
    CommonDecoderFrame_CopyPixels,
    CommonDecoderFrame_GetMetadataQueryReader,
    CommonDecoderFrame_GetColorContexts,
    CommonDecoderFrame_GetThumbnail
};

static HRESULT WINAPI CommonDecoderFrame_Block_QueryInterface(IWICMetadataBlockReader *iface, REFIID iid,
    void **ppv)
{
    CommonDecoderFrame *This = impl_from_IWICMetadataBlockReader(iface);
    return IWICBitmapFrameDecode_QueryInterface(&This->IWICBitmapFrameDecode_iface, iid, ppv);
}

static ULONG WINAPI CommonDecoderFrame_Block_AddRef(IWICMetadataBlockReader *iface)
{
    CommonDecoderFrame *This = impl_from_IWICMetadataBlockReader(iface);
    return IWICBitmapFrameDecode_AddRef(&This->IWICBitmapFrameDecode_iface);
}

static ULONG WINAPI CommonDecoderFrame_Block_Release(IWICMetadataBlockReader *iface)
{
    CommonDecoderFrame *This = impl_from_IWICMetadataBlockReader(iface);
    return IWICBitmapFrameDecode_Release(&This->IWICBitmapFrameDecode_iface);
}

static HRESULT WINAPI CommonDecoderFrame_Block_GetContainerFormat(IWICMetadataBlockReader *iface,
    GUID *pguidContainerFormat)
{
    CommonDecoderFrame *This = impl_from_IWICMetadataBlockReader(iface);
    if (!pguidContainerFormat) return E_INVALIDARG;
    *pguidContainerFormat = This->parent->decoder_info.block_format;
    return S_OK;
}

static HRESULT WINAPI CommonDecoderFrame_InitializeMetadata(CommonDecoderFrame *This)
{
    HRESULT hr=S_OK;

    if (This->metadata_initialized)
        return S_OK;

    EnterCriticalSection(&This->parent->lock);

    if (!This->metadata_initialized)
    {
        hr = decoder_get_metadata_blocks(This->parent->decoder, This->frame, &This->metadata_count, &This->metadata_blocks);
        if (SUCCEEDED(hr))
            This->metadata_initialized = TRUE;
    }

    LeaveCriticalSection(&This->parent->lock);

    return hr;
}

static HRESULT WINAPI CommonDecoderFrame_Block_GetCount(IWICMetadataBlockReader *iface,
    UINT *pcCount)
{
    CommonDecoderFrame *This = impl_from_IWICMetadataBlockReader(iface);
    HRESULT hr;

    TRACE("%p,%p\n", iface, pcCount);

    if (!pcCount) return E_INVALIDARG;

    hr = CommonDecoderFrame_InitializeMetadata(This);
    if (SUCCEEDED(hr))
        *pcCount = This->metadata_count;

    return hr;
}

static HRESULT WINAPI CommonDecoderFrame_Block_GetReaderByIndex(IWICMetadataBlockReader *iface,
    UINT nIndex, IWICMetadataReader **ppIMetadataReader)
{
    CommonDecoderFrame *This = impl_from_IWICMetadataBlockReader(iface);
    HRESULT hr;
    IWICComponentFactory* factory = NULL;
    IWICStream* stream;

    TRACE("%p,%d,%p\n", iface, nIndex, ppIMetadataReader);

    if (!ppIMetadataReader)
        return E_INVALIDARG;

    hr = CommonDecoderFrame_InitializeMetadata(This);

    if (SUCCEEDED(hr) && nIndex >= This->metadata_count)
        hr = E_INVALIDARG;

    if (SUCCEEDED(hr))
        hr = create_instance(&CLSID_WICImagingFactory, &IID_IWICComponentFactory, (void**)&factory);

    if (SUCCEEDED(hr))
        hr = IWICComponentFactory_CreateStream(factory, &stream);

    if (SUCCEEDED(hr))
    {
        if (This->metadata_blocks[nIndex].options & DECODER_BLOCK_FULL_STREAM)
        {
            LARGE_INTEGER offset;
            offset.QuadPart = This->metadata_blocks[nIndex].offset;

            hr = IWICStream_InitializeFromIStream(stream, This->parent->stream);

            if (SUCCEEDED(hr))
                hr = IWICStream_Seek(stream, offset, STREAM_SEEK_SET, NULL);
        }
        else
        {
            ULARGE_INTEGER offset, length;

            offset.QuadPart = This->metadata_blocks[nIndex].offset;
            length.QuadPart = This->metadata_blocks[nIndex].length;

            hr = IWICStream_InitializeFromIStreamRegion(stream, This->parent->stream,
                offset, length);
        }

        if (This->metadata_blocks[nIndex].options & DECODER_BLOCK_READER_CLSID)
        {
            IWICMetadataReader *reader;
            IWICPersistStream *persist;
            if (SUCCEEDED(hr))
            {
                hr = create_instance(&This->metadata_blocks[nIndex].reader_clsid,
                    &IID_IWICMetadataReader, (void**)&reader);
            }

            if (SUCCEEDED(hr))
            {
                hr = IWICMetadataReader_QueryInterface(reader, &IID_IWICPersistStream, (void**)&persist);

                if (SUCCEEDED(hr))
                {
                    hr = IWICPersistStream_LoadEx(persist, (IStream*)stream, NULL,
                        This->metadata_blocks[nIndex].options & DECODER_BLOCK_OPTION_MASK);

                    IWICPersistStream_Release(persist);
                }

                if (SUCCEEDED(hr))
                    *ppIMetadataReader = reader;
                else
                    IWICMetadataReader_Release(reader);
            }
        }
        else
        {
            hr = IWICComponentFactory_CreateMetadataReaderFromContainer(factory,
                &This->parent->decoder_info.block_format, NULL,
                This->metadata_blocks[nIndex].options & DECODER_BLOCK_OPTION_MASK,
                (IStream*)stream, ppIMetadataReader);
        }

        IWICStream_Release(stream);
    }

    if (factory) IWICComponentFactory_Release(factory);

    if (FAILED(hr))
        *ppIMetadataReader = NULL;

    return S_OK;
}

static HRESULT WINAPI CommonDecoderFrame_Block_GetEnumerator(IWICMetadataBlockReader *iface,
    IEnumUnknown **ppIEnumMetadata)
{
    FIXME("%p,%p\n", iface, ppIEnumMetadata);
    return E_NOTIMPL;
}

static const IWICMetadataBlockReaderVtbl CommonDecoderFrame_BlockVtbl = {
    CommonDecoderFrame_Block_QueryInterface,
    CommonDecoderFrame_Block_AddRef,
    CommonDecoderFrame_Block_Release,
    CommonDecoderFrame_Block_GetContainerFormat,
    CommonDecoderFrame_Block_GetCount,
    CommonDecoderFrame_Block_GetReaderByIndex,
    CommonDecoderFrame_Block_GetEnumerator,
};

static HRESULT WINAPI CommonDecoder_GetFrame(IWICBitmapDecoder *iface,
    UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
{
    CommonDecoder *This = impl_from_IWICBitmapDecoder(iface);
    HRESULT hr=S_OK;
    CommonDecoderFrame *result;

    TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);

    if (!ppIBitmapFrame)
        return E_INVALIDARG;

    EnterCriticalSection(&This->lock);

    if (!This->stream || index >= This->file_info.frame_count)
        hr = WINCODEC_ERR_FRAMEMISSING;

    if (SUCCEEDED(hr))
    {
        result = HeapAlloc(GetProcessHeap(), 0, sizeof(*result));
        if (!result)
            hr = E_OUTOFMEMORY;
    }

    if (SUCCEEDED(hr))
    {
        result->IWICBitmapFrameDecode_iface.lpVtbl = &CommonDecoderFrameVtbl;
        result->IWICMetadataBlockReader_iface.lpVtbl = &CommonDecoderFrame_BlockVtbl;
        result->ref = 1;
        result->parent = This;
        result->frame = index;
        result->metadata_initialized = FALSE;
        result->metadata_count = 0;
        result->metadata_blocks = NULL;

        hr = decoder_get_frame_info(This->decoder, index, &result->decoder_frame);

        if (SUCCEEDED(hr) && This->cache_options == WICDecodeMetadataCacheOnLoad)
            hr = CommonDecoderFrame_InitializeMetadata(result);

        if (FAILED(hr))
            HeapFree(GetProcessHeap(), 0, result);
    }

    LeaveCriticalSection(&This->lock);

    if (SUCCEEDED(hr))
    {
        TRACE("-> %ux%u, %u-bit pixelformat=%s res=%f,%f colors=%u contexts=%u\n",
            result->decoder_frame.width, result->decoder_frame.height,
            result->decoder_frame.bpp, wine_dbgstr_guid(&result->decoder_frame.pixel_format),
            result->decoder_frame.dpix, result->decoder_frame.dpiy,
            result->decoder_frame.num_colors, result->decoder_frame.num_color_contexts);
        IWICBitmapDecoder_AddRef(&This->IWICBitmapDecoder_iface);
        *ppIBitmapFrame = &result->IWICBitmapFrameDecode_iface;
    }
    else
    {
        *ppIBitmapFrame = NULL;
    }

    return hr;
}

HRESULT CommonDecoder_CreateInstance(struct decoder *decoder,
    const struct decoder_info *decoder_info, REFIID iid, void** ppv)
{
    CommonDecoder *This;
    HRESULT hr;

    TRACE("(%s,%s,%p)\n", debugstr_guid(&decoder_info->clsid), debugstr_guid(iid), ppv);

    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This)
    {
        decoder_destroy(decoder);
        return E_OUTOFMEMORY;
    }

    This->IWICBitmapDecoder_iface.lpVtbl = &CommonDecoder_Vtbl;
    This->ref = 1;
    This->stream = NULL;
    This->decoder = decoder;
    This->decoder_info = *decoder_info;
    InitializeCriticalSection(&This->lock);
    This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": CommonDecoder.lock");

    hr = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
    IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);

    return hr;
}