dlls/windowscodecs/bmpdecode.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 "wingdi.h"
  29 #include "objbase.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     DWORD bc2Size;
  40     DWORD bc2Width;
  41     DWORD bc2Height;
  42     WORD  bc2Planes;
  43     WORD  bc2BitCount;
  44     DWORD bc2Compression;
  45     DWORD bc2SizeImage;
  46     DWORD bc2XRes;
  47     DWORD bc2YRes;
  48     DWORD bc2ClrUsed;
  49     DWORD bc2ClrImportant;
  50     /* same as BITMAPINFOHEADER until this point */
  51     WORD  bc2ResUnit;
  52     WORD  bc2Reserved;
  53     WORD  bc2Orientation;
  54     WORD  bc2Halftoning;
  55     DWORD bc2HalftoneSize1;
  56     DWORD bc2HalftoneSize2;
  57     DWORD bc2ColorSpace;
  58     DWORD bc2AppData;
  59 } BITMAPCOREHEADER2;
  60
  61 typedef struct {
  62     const IWICBitmapFrameDecodeVtbl *lpVtbl;
  63     LONG ref;
  64     IStream *stream;
  65     BITMAPFILEHEADER bfh;
  66     BITMAPV5HEADER bih;
  67 } BmpFrameDecode;
  68
  69 HRESULT WINAPI BmpFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
  70     void **ppv)
  71 {
  72     BmpFrameDecode *This = (BmpFrameDecode*)iface;
  73     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  74
  75     if (!ppv) return E_INVALIDARG;
  76
  77     if (IsEqualIID(&IID_IUnknown, iid) ||
  78         IsEqualIID(&IID_IWICBitmapSource, iid) ||
  79         IsEqualIID(&IID_IWICBitmapFrameDecode, iid))
  80     {
  81         *ppv = This;
  82     }
  83     else
  84     {
  85         *ppv = NULL;
  86         return E_NOINTERFACE;
  87     }
  88
  89     IUnknown_AddRef((IUnknown*)*ppv);
  90     return S_OK;
  91 }
  92
  93 static ULONG WINAPI BmpFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
  94 {
  95     BmpFrameDecode *This = (BmpFrameDecode*)iface;
  96     ULONG ref = InterlockedIncrement(&This->ref);
  97
  98     TRACE("(%p) refcount=%u\n", iface, ref);
  99
 100     return ref;
 101 }
 102
 103 static ULONG WINAPI BmpFrameDecode_Release(IWICBitmapFrameDecode *iface)
 104 {
 105     BmpFrameDecode *This = (BmpFrameDecode*)iface;
 106     ULONG ref = InterlockedDecrement(&This->ref);
 107
 108     TRACE("(%p) refcount=%u\n", iface, ref);
 109
 110     if (ref == 0)
 111     {
 112         IStream_Release(This->stream);
 113         HeapFree(GetProcessHeap(), 0, This);
 114     }
 115
 116     return ref;
 117 }
 118
 119 static HRESULT WINAPI BmpFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
 120     UINT *puiWidth, UINT *puiHeight)
 121 {
 122     FIXME("(%p,%p,%p): stub\n", iface, puiWidth, puiHeight);
 123     return E_NOTIMPL;
 124 }
 125
 126 static HRESULT WINAPI BmpFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
 127     WICPixelFormatGUID *pPixelFormat)
 128 {
 129     FIXME("(%p,%p): stub\n", iface, pPixelFormat);
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI BmpFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
 134     double *pDpiX, double *pDpiY)
 135 {
 136     FIXME("(%p,%p,%p): stub\n", iface, pDpiX, pDpiY);
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT WINAPI BmpFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
 141     IWICPalette *pIPalette)
 142 {
 143     FIXME("(%p,%p): stub\n", iface, pIPalette);
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI BmpFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
 148     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 149 {
 150     FIXME("(%p,%p,%u,%u,%p): stub\n", iface, prc, cbStride, cbBufferSize, pbBuffer);
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI BmpFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
 155     IWICMetadataQueryReader **ppIMetadataQueryReader)
 156 {
 157     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
 158     return E_NOTIMPL;
 159 }
 160
 161 static HRESULT WINAPI BmpFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
 162     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 163 {
 164     FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
 165     return E_NOTIMPL;
 166 }
 167
 168 static HRESULT WINAPI BmpFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
 169     IWICBitmapSource **ppIThumbnail)
 170 {
 171     FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
 172     return E_NOTIMPL;
 173 }
 174
 175 static const IWICBitmapFrameDecodeVtbl BmpFrameDecode_Vtbl = {
 176     BmpFrameDecode_QueryInterface,
 177     BmpFrameDecode_AddRef,
 178     BmpFrameDecode_Release,
 179     BmpFrameDecode_GetSize,
 180     BmpFrameDecode_GetPixelFormat,
 181     BmpFrameDecode_GetResolution,
 182     BmpFrameDecode_CopyPalette,
 183     BmpFrameDecode_CopyPixels,
 184     BmpFrameDecode_GetMetadataQueryReader,
 185     BmpFrameDecode_GetColorContexts,
 186     BmpFrameDecode_GetThumbnail
 187 };
 188
 189 typedef struct {
 190     const IWICBitmapDecoderVtbl *lpVtbl;
 191     LONG ref;
 192     BOOL initialized;
 193     IStream *stream;
 194     BITMAPFILEHEADER bfh;
 195     BITMAPV5HEADER bih;
 196     BmpFrameDecode *framedecode;
 197 } BmpDecoder;
 198
 199 static HRESULT BmpDecoder_ReadHeaders(BmpDecoder* This, IStream *stream)
 200 {
 201     HRESULT hr;
 202     ULONG bytestoread, bytesread;
 203
 204     if (This->initialized) return WINCODEC_ERR_WRONGSTATE;
 205
 206     hr = IStream_Read(stream, &This->bfh, sizeof(BITMAPFILEHEADER), &bytesread);
 207     if (FAILED(hr)) return hr;
 208     if (bytesread != sizeof(BITMAPFILEHEADER) ||
 209         This->bfh.bfType != 0x4d42 /* "BM" */) return E_FAIL;
 210
 211     hr = IStream_Read(stream, &This->bih.bV5Size, sizeof(DWORD), &bytesread);
 212     if (FAILED(hr)) return hr;
 213     if (bytesread != sizeof(DWORD) ||
 214         (This->bih.bV5Size != sizeof(BITMAPCOREHEADER) &&
 215          This->bih.bV5Size != sizeof(BITMAPCOREHEADER2) &&
 216          This->bih.bV5Size != sizeof(BITMAPINFOHEADER) &&
 217          This->bih.bV5Size != sizeof(BITMAPV4HEADER) &&
 218          This->bih.bV5Size != sizeof(BITMAPV5HEADER))) return E_FAIL;
 219
 220     bytestoread = This->bih.bV5Size-sizeof(DWORD);
 221     hr = IStream_Read(stream, &This->bih.bV5Width, bytestoread, &bytesread);
 222     if (FAILED(hr)) return hr;
 223     if (bytestoread != bytesread) return E_FAIL;
 224
 225     This->initialized = TRUE;
 226
 227     return S_OK;
 228 }
 229
 230 HRESULT WINAPI BmpDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
 231     void **ppv)
 232 {
 233     BmpDecoder *This = (BmpDecoder*)iface;
 234     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 235
 236     if (!ppv) return E_INVALIDARG;
 237
 238     if (IsEqualIID(&IID_IUnknown, iid) || IsEqualIID(&IID_IWICBitmapDecoder, iid))
 239     {
 240         *ppv = This;
 241     }
 242     else
 243     {
 244         *ppv = NULL;
 245         return E_NOINTERFACE;
 246     }
 247
 248     IUnknown_AddRef((IUnknown*)*ppv);
 249     return S_OK;
 250 }
 251
 252 static ULONG WINAPI BmpDecoder_AddRef(IWICBitmapDecoder *iface)
 253 {
 254     BmpDecoder *This = (BmpDecoder*)iface;
 255     ULONG ref = InterlockedIncrement(&This->ref);
 256
 257     TRACE("(%p) refcount=%u\n", iface, ref);
 258
 259     return ref;
 260 }
 261
 262 static ULONG WINAPI BmpDecoder_Release(IWICBitmapDecoder *iface)
 263 {
 264     BmpDecoder *This = (BmpDecoder*)iface;
 265     ULONG ref = InterlockedDecrement(&This->ref);
 266
 267     TRACE("(%p) refcount=%u\n", iface, ref);
 268
 269     if (ref == 0)
 270     {
 271         if (This->stream) IStream_Release(This->stream);
 272         if (This->framedecode) IUnknown_Release((IUnknown*)This->framedecode);
 273         HeapFree(GetProcessHeap(), 0, This);
 274     }
 275
 276     return ref;
 277 }
 278
 279 static HRESULT WINAPI BmpDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *pIStream,
 280     DWORD *pdwCapability)
 281 {
 282     FIXME("(%p,%p,%p): stub\n", iface, pIStream, pdwCapability);
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT WINAPI BmpDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
 287     WICDecodeOptions cacheOptions)
 288 {
 289     HRESULT hr;
 290     BmpDecoder *This = (BmpDecoder*)iface;
 291
 292     hr = BmpDecoder_ReadHeaders(This, pIStream);
 293
 294     if (SUCCEEDED(hr))
 295     {
 296         This->stream = pIStream;
 297         IStream_AddRef(pIStream);
 298     }
 299
 300     return hr;
 301 }
 302
 303 static HRESULT WINAPI BmpDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
 304     GUID *pguidContainerFormat)
 305 {
 306     memcpy(pguidContainerFormat, &GUID_ContainerFormatBmp, sizeof(GUID));
 307     return S_OK;
 308 }
 309
 310 static HRESULT WINAPI BmpDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
 311     IWICBitmapDecoderInfo **ppIDecoderInfo)
 312 {
 313     FIXME("(%p,%p): stub\n", iface, ppIDecoderInfo);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI BmpDecoder_CopyPalette(IWICBitmapDecoder *iface,
 318     IWICPalette *pIPalette)
 319 {
 320     FIXME("(%p,%p): stub\n", iface, pIPalette);
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI BmpDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
 325     IWICMetadataQueryReader **ppIMetadataQueryReader)
 326 {
 327     FIXME("(%p,%p): stub\n", iface, ppIMetadataQueryReader);
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI BmpDecoder_GetPreview(IWICBitmapDecoder *iface,
 332     IWICBitmapSource **ppIBitmapSource)
 333 {
 334     FIXME("(%p,%p): stub\n", iface, ppIBitmapSource);
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI BmpDecoder_GetColorContexts(IWICBitmapDecoder *iface,
 339     UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 340 {
 341     FIXME("(%p,%u,%p,%p): stub\n", iface, cCount, ppIColorContexts, pcActualCount);
 342     return E_NOTIMPL;
 343 }
 344
 345 static HRESULT WINAPI BmpDecoder_GetThumbnail(IWICBitmapDecoder *iface,
 346     IWICBitmapSource **ppIThumbnail)
 347 {
 348     FIXME("(%p,%p): stub\n", iface, ppIThumbnail);
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT WINAPI BmpDecoder_GetFrameCount(IWICBitmapDecoder *iface,
 353     UINT *pCount)
 354 {
 355     *pCount = 1;
 356     return S_OK;
 357 }
 358
 359 static HRESULT WINAPI BmpDecoder_GetFrame(IWICBitmapDecoder *iface,
 360     UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 361 {
 362     BmpDecoder *This = (BmpDecoder*)iface;
 363
 364     if (index != 0) return E_INVALIDARG;
 365
 366     if (!This->stream) return WINCODEC_ERR_WRONGSTATE;
 367
 368     if (!This->framedecode)
 369     {
 370         This->framedecode = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpFrameDecode));
 371         if (!This->framedecode) return E_OUTOFMEMORY;
 372
 373         This->framedecode->lpVtbl = &BmpFrameDecode_Vtbl;
 374         This->framedecode->ref = 1;
 375         This->framedecode->stream = This->stream;
 376         IStream_AddRef(This->stream);
 377         This->framedecode->bfh = This->bfh;
 378         This->framedecode->bih = This->bih;
 379     }
 380
 381     *ppIBitmapFrame = (IWICBitmapFrameDecode*)This->framedecode;
 382     IWICBitmapFrameDecode_AddRef((IWICBitmapFrameDecode*)This->framedecode);
 383
 384     return S_OK;
 385 }
 386
 387 static const IWICBitmapDecoderVtbl BmpDecoder_Vtbl = {
 388     BmpDecoder_QueryInterface,
 389     BmpDecoder_AddRef,
 390     BmpDecoder_Release,
 391     BmpDecoder_QueryCapability,
 392     BmpDecoder_Initialize,
 393     BmpDecoder_GetContainerFormat,
 394     BmpDecoder_GetDecoderInfo,
 395     BmpDecoder_CopyPalette,
 396     BmpDecoder_GetMetadataQueryReader,
 397     BmpDecoder_GetPreview,
 398     BmpDecoder_GetColorContexts,
 399     BmpDecoder_GetThumbnail,
 400     BmpDecoder_GetFrameCount,
 401     BmpDecoder_GetFrame
 402 };
 403
 404 HRESULT BmpDecoder_CreateInstance(IUnknown *pUnkOuter, REFIID iid, void** ppv)
 405 {
 406     BmpDecoder *This;
 407     HRESULT ret;
 408
 409     TRACE("(%p,%s,%p)\n", pUnkOuter, debugstr_guid(iid), ppv);
 410
 411     *ppv = NULL;
 412
 413     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
 414
 415     This = HeapAlloc(GetProcessHeap(), 0, sizeof(BmpDecoder));
 416     if (!This) return E_OUTOFMEMORY;
 417
 418     This->lpVtbl = &BmpDecoder_Vtbl;
 419     This->ref = 1;
 420     This->initialized = FALSE;
 421     This->stream = NULL;
 422     This->framedecode = NULL;
 423
 424     ret = IUnknown_QueryInterface((IUnknown*)This, iid, ppv);
 425     IUnknown_Release((IUnknown*)This);
 426
 427     return ret;
 428 }