dlls/windowscodecs/imgfactory.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winreg.h"
  28 #include "objbase.h"
  29 #include "shellapi.h"
  30 #include "wincodec.h"
  31
  32 #include "wincodecs_private.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  37
  38 typedef struct {
  39     IWICImagingFactory IWICImagingFactory_iface;
  40     LONG ref;
  41 } ImagingFactory;
  42
  43 static inline ImagingFactory *impl_from_IWICImagingFactory(IWICImagingFactory *iface)
  44 {
  45     return CONTAINING_RECORD(iface, ImagingFactory, IWICImagingFactory_iface);
  46 }
  47
  48 static HRESULT WINAPI ImagingFactory_QueryInterface(IWICImagingFactory *iface, REFIID iid,
  49     void **ppv)
  50 {
  51     ImagingFactory *This = impl_from_IWICImagingFactory(iface);
  52     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  53
  54     if (!ppv) return E_INVALIDARG;
  55
  56     if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICImagingFactory, iid))
  57     {
  58         *ppv = This;
  59     }
  60     else
  61     {
  62         *ppv = NULL;
  63         return E_NOINTERFACE;
  64     }
  65
  66     IUnknown_AddRef((IUnknown*)*ppv);
  67     return S_OK;
  68 }
  69
  70 static ULONG WINAPI ImagingFactory_AddRef(IWICImagingFactory *iface)
  71 {
  72     ImagingFactory *This = impl_from_IWICImagingFactory(iface);
  73     ULONG ref = InterlockedIncrement(&This->ref);
  74
  75     TRACE("(%p) refcount=%u\n", iface, ref);
  76
  77     return ref;
  78 }
  79
  80 static ULONG WINAPI ImagingFactory_Release(IWICImagingFactory *iface)
  81 {
  82     ImagingFactory *This = impl_from_IWICImagingFactory(iface);
  83     ULONG ref = InterlockedDecrement(&This->ref);
  84
  85     TRACE("(%p) refcount=%u\n", iface, ref);
  86
  87     if (ref == 0)
  88         HeapFree(GetProcessHeap(), 0, This);
  89
  90     return ref;
  91 }
  92
  93 static HRESULT WINAPI ImagingFactory_CreateDecoderFromFilename(
  94     IWICImagingFactory *iface, LPCWSTR wzFilename, const GUID *pguidVendor,
  95     DWORD dwDesiredAccess, WICDecodeOptions metadataOptions,
  96     IWICBitmapDecoder **ppIDecoder)
  97 {
  98     IWICStream *stream;
  99     HRESULT hr;
 100
 101     TRACE("(%p,%s,%s,%u,%u,%p)\n", iface, debugstr_w(wzFilename),
 102         debugstr_guid(pguidVendor), dwDesiredAccess, metadataOptions, ppIDecoder);
 103
 104     hr = StreamImpl_Create(&stream);
 105     if (SUCCEEDED(hr))
 106     {
 107         hr = IWICStream_InitializeFromFilename(stream, wzFilename, dwDesiredAccess);
 108
 109         if (SUCCEEDED(hr))
 110         {
 111             hr = IWICImagingFactory_CreateDecoderFromStream(iface, (IStream*)stream,
 112                 pguidVendor, metadataOptions, ppIDecoder);
 113         }
 114
 115         IWICStream_Release(stream);
 116     }
 117
 118     return hr;
 119 }
 120
 121 static HRESULT WINAPI ImagingFactory_CreateDecoderFromStream(
 122     IWICImagingFactory *iface, IStream *pIStream, const GUID *pguidVendor,
 123     WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 124 {
 125     static int fixme=0;
 126     IEnumUnknown *enumdecoders;
 127     IUnknown *unkdecoderinfo;
 128     IWICBitmapDecoderInfo *decoderinfo;
 129     IWICBitmapDecoder *decoder=NULL;
 130     HRESULT res=S_OK;
 131     ULONG num_fetched;
 132     BOOL matches;
 133
 134     TRACE("(%p,%p,%s,%u,%p)\n", iface, pIStream, debugstr_guid(pguidVendor),
 135         metadataOptions, ppIDecoder);
 136
 137     if (pguidVendor && !fixme++)
 138         FIXME("ignoring vendor GUID\n");
 139
 140     res = CreateComponentEnumerator(WICDecoder, WICComponentEnumerateDefault, &enumdecoders);
 141     if (FAILED(res)) return res;
 142
 143     while (!decoder)
 144     {
 145         res = IEnumUnknown_Next(enumdecoders, 1, &unkdecoderinfo, &num_fetched);
 146
 147         if (res == S_OK)
 148         {
 149             res = IUnknown_QueryInterface(unkdecoderinfo, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
 150
 151             if (SUCCEEDED(res))
 152             {
 153                 res = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, pIStream, &matches);
 154
 155                 if (SUCCEEDED(res) && matches)
 156                 {
 157                     res = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
 158
 159                     /* FIXME: should use QueryCapability to choose a decoder */
 160
 161                     if (SUCCEEDED(res))
 162                     {
 163                         res = IWICBitmapDecoder_Initialize(decoder, pIStream, metadataOptions);
 164
 165                         if (FAILED(res))
 166                         {
 167                             IWICBitmapDecoder_Release(decoder);
 168                             decoder = NULL;
 169                         }
 170                     }
 171                 }
 172
 173                 IWICBitmapDecoderInfo_Release(decoderinfo);
 174             }
 175
 176             IUnknown_Release(unkdecoderinfo);
 177         }
 178         else
 179             break;
 180     }
 181
 182     IEnumUnknown_Release(enumdecoders);
 183
 184     if (decoder)
 185     {
 186         *ppIDecoder = decoder;
 187         return S_OK;
 188     }
 189     else
 190     {
 191         if (WARN_ON(wincodecs))
 192         {
 193             LARGE_INTEGER seek;
 194             BYTE data[4];
 195             ULONG bytesread;
 196
 197             WARN("failed to load from a stream\n");
 198
 199             seek.QuadPart = 0;
 200             res = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, NULL);
 201             if (SUCCEEDED(res))
 202                 res = IStream_Read(pIStream, data, 4, &bytesread);
 203             if (SUCCEEDED(res))
 204                 WARN("first %i bytes of stream=%x %x %x %x\n", bytesread, data[0], data[1], data[2], data[3]);
 205         }
 206         *ppIDecoder = NULL;
 207         return WINCODEC_ERR_COMPONENTNOTFOUND;
 208     }
 209 }
 210
 211 static HRESULT WINAPI ImagingFactory_CreateDecoderFromFileHandle(
 212     IWICImagingFactory *iface, ULONG_PTR hFile, const GUID *pguidVendor,
 213     WICDecodeOptions metadataOptions, IWICBitmapDecoder **ppIDecoder)
 214 {
 215     FIXME("(%p,%lx,%s,%u,%p): stub\n", iface, hFile, debugstr_guid(pguidVendor),
 216         metadataOptions, ppIDecoder);
 217     return E_NOTIMPL;
 218 }
 219
 220 static HRESULT WINAPI ImagingFactory_CreateComponentInfo(IWICImagingFactory *iface,
 221     REFCLSID clsidComponent, IWICComponentInfo **ppIInfo)
 222 {
 223     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(clsidComponent), ppIInfo);
 224     return CreateComponentInfo(clsidComponent, ppIInfo);
 225 }
 226
 227 static HRESULT WINAPI ImagingFactory_CreateDecoder(IWICImagingFactory *iface,
 228     REFGUID guidContainerFormat, const GUID *pguidVendor,
 229     IWICBitmapDecoder **ppIDecoder)
 230 {
 231     FIXME("(%p,%s,%s,%p): stub\n", iface, debugstr_guid(guidContainerFormat),
 232         debugstr_guid(pguidVendor), ppIDecoder);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI ImagingFactory_CreateEncoder(IWICImagingFactory *iface,
 237     REFGUID guidContainerFormat, const GUID *pguidVendor,
 238     IWICBitmapEncoder **ppIEncoder)
 239 {
 240     FIXME("(%p,%s,%s,%p): stub\n", iface, debugstr_guid(guidContainerFormat),
 241         debugstr_guid(pguidVendor), ppIEncoder);
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI ImagingFactory_CreatePalette(IWICImagingFactory *iface,
 246     IWICPalette **ppIPalette)
 247 {
 248     TRACE("(%p,%p)\n", iface, ppIPalette);
 249     return PaletteImpl_Create(ppIPalette);
 250 }
 251
 252 static HRESULT WINAPI ImagingFactory_CreateFormatConverter(IWICImagingFactory *iface,
 253     IWICFormatConverter **ppIFormatConverter)
 254 {
 255     return FormatConverter_CreateInstance(NULL, &IID_IWICFormatConverter, (void**)ppIFormatConverter);
 256 }
 257
 258 static HRESULT WINAPI ImagingFactory_CreateBitmapScaler(IWICImagingFactory *iface,
 259     IWICBitmapScaler **ppIBitmapScaler)
 260 {
 261     FIXME("(%p,%p): stub\n", iface, ppIBitmapScaler);
 262     return E_NOTIMPL;
 263 }
 264
 265 static HRESULT WINAPI ImagingFactory_CreateBitmapClipper(IWICImagingFactory *iface,
 266     IWICBitmapClipper **ppIBitmapClipper)
 267 {
 268     FIXME("(%p,%p): stub\n", iface, ppIBitmapClipper);
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI ImagingFactory_CreateBitmapFlipRotator(IWICImagingFactory *iface,
 273     IWICBitmapFlipRotator **ppIBitmapFlipRotator)
 274 {
 275     TRACE("(%p,%p)\n", iface, ppIBitmapFlipRotator);
 276     return FlipRotator_Create(ppIBitmapFlipRotator);
 277 }
 278
 279 static HRESULT WINAPI ImagingFactory_CreateStream(IWICImagingFactory *iface,
 280     IWICStream **ppIWICStream)
 281 {
 282     TRACE("(%p,%p)\n", iface, ppIWICStream);
 283     return StreamImpl_Create(ppIWICStream);
 284 }
 285
 286 static HRESULT WINAPI ImagingFactory_CreateColorContext(IWICImagingFactory *iface,
 287     IWICColorContext **ppIColorContext)
 288 {
 289     FIXME("(%p,%p): stub\n", iface, ppIColorContext);
 290     return E_NOTIMPL;
 291 }
 292
 293 static HRESULT WINAPI ImagingFactory_CreateColorTransformer(IWICImagingFactory *iface,
 294     IWICColorTransform **ppIColorTransform)
 295 {
 296     FIXME("(%p,%p): stub\n", iface, ppIColorTransform);
 297     return E_NOTIMPL;
 298 }
 299
 300 static HRESULT WINAPI ImagingFactory_CreateBitmap(IWICImagingFactory *iface,
 301     UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat,
 302     WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap)
 303 {
 304     FIXME("(%p,%u,%u,%s,%u,%p): stub\n", iface, uiWidth, uiHeight,
 305         debugstr_guid(pixelFormat), option, ppIBitmap);
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI ImagingFactory_CreateBitmapFromSource(IWICImagingFactory *iface,
 310     IWICBitmapSource *piBitmapSource, WICBitmapCreateCacheOption option,
 311     IWICBitmap **ppIBitmap)
 312 {
 313     FIXME("(%p,%p,%u,%p): stub\n", iface, piBitmapSource, option, ppIBitmap);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI ImagingFactory_CreateBitmapFromSourceRect(IWICImagingFactory *iface,
 318     IWICBitmapSource *piBitmapSource, UINT x, UINT y, UINT width, UINT height,
 319     IWICBitmap **ppIBitmap)
 320 {
 321     FIXME("(%p,%p,%u,%u,%u,%u,%p): stub\n", iface, piBitmapSource, x, y, width,
 322         height, ppIBitmap);
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI ImagingFactory_CreateBitmapFromMemory(IWICImagingFactory *iface,
 327     UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat, UINT cbStride,
 328     UINT cbBufferSize, BYTE *pbBuffer, IWICBitmap **ppIBitmap)
 329 {
 330     FIXME("(%p,%u,%u,%s,%u,%u,%p,%p): stub\n", iface, uiWidth, uiHeight,
 331         debugstr_guid(pixelFormat), cbStride, cbBufferSize, pbBuffer, ppIBitmap);
 332     return E_NOTIMPL;
 333 }
 334
 335 static HRESULT WINAPI ImagingFactory_CreateBitmapFromHBITMAP(IWICImagingFactory *iface,
 336     HBITMAP hBitmap, HPALETTE hPalette, WICBitmapAlphaChannelOption options,
 337     IWICBitmap **ppIBitmap)
 338 {
 339     FIXME("(%p,%p,%p,%u,%p): stub\n", iface, hBitmap, hPalette, options, ppIBitmap);
 340     return E_NOTIMPL;
 341 }
 342
 343 static HRESULT WINAPI ImagingFactory_CreateBitmapFromHICON(IWICImagingFactory *iface,
 344     HICON hIcon, IWICBitmap **ppIBitmap)
 345 {
 346     FIXME("(%p,%p,%p): stub\n", iface, hIcon, ppIBitmap);
 347     return E_NOTIMPL;
 348 }
 349
 350 static HRESULT WINAPI ImagingFactory_CreateComponentEnumerator(IWICImagingFactory *iface,
 351     DWORD componentTypes, DWORD options, IEnumUnknown **ppIEnumUnknown)
 352 {
 353     TRACE("(%p,%u,%u,%p)\n", iface, componentTypes, options, ppIEnumUnknown);
 354     return CreateComponentEnumerator(componentTypes, options, ppIEnumUnknown);
 355 }
 356
 357 static HRESULT WINAPI ImagingFactory_CreateFastMetadataEncoderFromDecoder(
 358     IWICImagingFactory *iface, IWICBitmapDecoder *pIDecoder,
 359     IWICFastMetadataEncoder **ppIFastEncoder)
 360 {
 361     FIXME("(%p,%p,%p): stub\n", iface, pIDecoder, ppIFastEncoder);
 362     return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI ImagingFactory_CreateFastMetadataEncoderFromFrameDecode(
 366     IWICImagingFactory *iface, IWICBitmapFrameDecode *pIFrameDecoder,
 367     IWICFastMetadataEncoder **ppIFastEncoder)
 368 {
 369     FIXME("(%p,%p,%p): stub\n", iface, pIFrameDecoder, ppIFastEncoder);
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI ImagingFactory_CreateQueryWriter(IWICImagingFactory *iface,
 374     REFGUID guidMetadataFormat, const GUID *pguidVendor,
 375     IWICMetadataQueryWriter **ppIQueryWriter)
 376 {
 377     FIXME("(%p,%s,%s,%p): stub\n", iface, debugstr_guid(guidMetadataFormat),
 378         debugstr_guid(pguidVendor), ppIQueryWriter);
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI ImagingFactory_CreateQueryWriterFromReader(IWICImagingFactory *iface,
 383     IWICMetadataQueryReader *pIQueryReader, const GUID *pguidVendor,
 384     IWICMetadataQueryWriter **ppIQueryWriter)
 385 {
 386     FIXME("(%p,%p,%s,%p): stub\n", iface, pIQueryReader, debugstr_guid(pguidVendor),
 387         ppIQueryWriter);
 388     return E_NOTIMPL;
 389 }
 390
 391 static const IWICImagingFactoryVtbl ImagingFactory_Vtbl = {
 392     ImagingFactory_QueryInterface,
 393     ImagingFactory_AddRef,
 394     ImagingFactory_Release,
 395     ImagingFactory_CreateDecoderFromFilename,
 396     ImagingFactory_CreateDecoderFromStream,
 397     ImagingFactory_CreateDecoderFromFileHandle,
 398     ImagingFactory_CreateComponentInfo,
 399     ImagingFactory_CreateDecoder,
 400     ImagingFactory_CreateEncoder,
 401     ImagingFactory_CreatePalette,
 402     ImagingFactory_CreateFormatConverter,
 403     ImagingFactory_CreateBitmapScaler,
 404     ImagingFactory_CreateBitmapClipper,
 405     ImagingFactory_CreateBitmapFlipRotator,
 406     ImagingFactory_CreateStream,
 407     ImagingFactory_CreateColorContext,
 408     ImagingFactory_CreateColorTransformer,
 409     ImagingFactory_CreateBitmap,
 410     ImagingFactory_CreateBitmapFromSource,
 411     ImagingFactory_CreateBitmapFromSourceRect,
 412     ImagingFactory_CreateBitmapFromMemory,
 413     ImagingFactory_CreateBitmapFromHBITMAP,
 414     ImagingFactory_CreateBitmapFromHICON,
 415     ImagingFactory_CreateComponentEnumerator,
 416     ImagingFactory_CreateFastMetadataEncoderFromDecoder,
 417     ImagingFactory_CreateFastMetadataEncoderFromFrameDecode,
 418     ImagingFactory_CreateQueryWriter,
 419     ImagingFactory_CreateQueryWriterFromReader
 420 };
 421
 422 HRESULT ImagingFactory_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
 423 {
 424     ImagingFactory *This;
 425     HRESULT ret;
 426
 427     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
 428
 429     *ppv = NULL;
 430
 431     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 432
 433     This = HeapAlloc(GetProcessHeap(), 0, sizeof(ImagingFactory));
 434     if (!This) return E_OUTOFMEMORY;
 435
 436     This->IWICImagingFactory_iface.lpVtbl = &ImagingFactory_Vtbl;
 437     This->ref = 1;
 438
 439     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
 440     IUnknown_Release((IUnknown*)This);
 441
 442     return ret;
 443 }