dlls/windowscodecs/scaler.c

   1 /*
   2  * Copyright 2010 Vincent Povirk for CodeWeavers
   3  * Copyright 2016 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "objbase.h"
  29
  30 #include "wincodecs_private.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  35
  36 typedef struct BitmapScaler {
  37     IWICBitmapScaler IWICBitmapScaler_iface;
  38     LONG ref;
  39     IMILBitmapScaler IMILBitmapScaler_iface;
  40     IWICBitmapSource *source;
  41     UINT width, height;
  42     UINT src_width, src_height;
  43     WICBitmapInterpolationMode mode;
  44     UINT bpp;
  45     void (*fn_get_required_source_rect)(struct BitmapScaler*,UINT,UINT,WICRect*);
  46     void (*fn_copy_scanline)(struct BitmapScaler*,UINT,UINT,UINT,BYTE**,UINT,UINT,BYTE*);
  47     CRITICAL_SECTION lock; /* must be held when initialized */
  48 } BitmapScaler;
  49
  50 static inline BitmapScaler *impl_from_IWICBitmapScaler(IWICBitmapScaler *iface)
  51 {
  52     return CONTAINING_RECORD(iface, BitmapScaler, IWICBitmapScaler_iface);
  53 }
  54
  55 static inline BitmapScaler *impl_from_IMILBitmapScaler(IMILBitmapScaler *iface)
  56 {
  57     return CONTAINING_RECORD(iface, BitmapScaler, IMILBitmapScaler_iface);
  58 }
  59
  60 static HRESULT WINAPI BitmapScaler_QueryInterface(IWICBitmapScaler *iface, REFIID iid,
  61     void **ppv)
  62 {
  63     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
  64     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  65
  66     if (!ppv) return E_INVALIDARG;
  67
  68     if (IsEqualIID(&IID_IUnknown, iid) ||
  69         IsEqualIID(&IID_IWICBitmapSource, iid) ||
  70         IsEqualIID(&IID_IWICBitmapScaler, iid))
  71     {
  72         *ppv = &This->IWICBitmapScaler_iface;
  73     }
  74     else if (IsEqualIID(&IID_IMILBitmapScaler, iid))
  75     {
  76         *ppv = &This->IMILBitmapScaler_iface;
  77     }
  78     else
  79     {
  80         FIXME("unknown interface %s\n", debugstr_guid(iid));
  81         *ppv = NULL;
  82         return E_NOINTERFACE;
  83     }
  84
  85     IUnknown_AddRef((IUnknown*)*ppv);
  86     return S_OK;
  87 }
  88
  89 static ULONG WINAPI BitmapScaler_AddRef(IWICBitmapScaler *iface)
  90 {
  91     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
  92     ULONG ref = InterlockedIncrement(&This->ref);
  93
  94     TRACE("(%p) refcount=%u\n", iface, ref);
  95
  96     return ref;
  97 }
  98
  99 static ULONG WINAPI BitmapScaler_Release(IWICBitmapScaler *iface)
 100 {
 101     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
 102     ULONG ref = InterlockedDecrement(&This->ref);
 103
 104     TRACE("(%p) refcount=%u\n", iface, ref);
 105
 106     if (ref == 0)
 107     {
 108         This->lock.DebugInfo->Spare[0] = 0;
 109         DeleteCriticalSection(&This->lock);
 110         if (This->source) IWICBitmapSource_Release(This->source);
 111         HeapFree(GetProcessHeap(), 0, This);
 112     }
 113
 114     return ref;
 115 }
 116
 117 static HRESULT WINAPI BitmapScaler_GetSize(IWICBitmapScaler *iface,
 118     UINT *puiWidth, UINT *puiHeight)
 119 {
 120     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
 121     TRACE("(%p,%p,%p)\n", iface, puiWidth, puiHeight);
 122
 123     if (!This->source)
 124         return WINCODEC_ERR_NOTINITIALIZED;
 125
 126     if (!puiWidth || !puiHeight)
 127         return E_INVALIDARG;
 128
 129     *puiWidth = This->width;
 130     *puiHeight = This->height;
 131
 132     return S_OK;
 133 }
 134
 135 static HRESULT WINAPI BitmapScaler_GetPixelFormat(IWICBitmapScaler *iface,
 136     WICPixelFormatGUID *pPixelFormat)
 137 {
 138     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
 139     TRACE("(%p,%p)\n", iface, pPixelFormat);
 140
 141     if (!pPixelFormat)
 142         return E_INVALIDARG;
 143
 144     if (!This->source)
 145     {
 146         memcpy(pPixelFormat, &GUID_WICPixelFormatDontCare, sizeof(*pPixelFormat));
 147         return S_OK;
 148     }
 149
 150     return IWICBitmapSource_GetPixelFormat(This->source, pPixelFormat);
 151 }
 152
 153 static HRESULT WINAPI BitmapScaler_GetResolution(IWICBitmapScaler *iface,
 154     double *pDpiX, double *pDpiY)
 155 {
 156     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
 157     TRACE("(%p,%p,%p)\n", iface, pDpiX, pDpiY);
 158
 159     if (!This->source)
 160         return WINCODEC_ERR_NOTINITIALIZED;
 161
 162     if (!pDpiX || !pDpiY)
 163         return E_INVALIDARG;
 164
 165     return IWICBitmapSource_GetResolution(This->source, pDpiX, pDpiY);
 166 }
 167
 168 static HRESULT WINAPI BitmapScaler_CopyPalette(IWICBitmapScaler *iface,
 169     IWICPalette *pIPalette)
 170 {
 171     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
 172     TRACE("(%p,%p)\n", iface, pIPalette);
 173
 174     if (!pIPalette)
 175         return E_INVALIDARG;
 176
 177     if (!This->source)
 178         return WINCODEC_ERR_PALETTEUNAVAILABLE;
 179
 180     return IWICBitmapSource_CopyPalette(This->source, pIPalette);
 181 }
 182
 183 static void NearestNeighbor_GetRequiredSourceRect(BitmapScaler *This,
 184     UINT x, UINT y, WICRect *src_rect)
 185 {
 186     src_rect->X = x * This->src_width / This->width;
 187     src_rect->Y = y * This->src_height / This->height;
 188     src_rect->Width = src_rect->Height = 1;
 189 }
 190
 191 static void NearestNeighbor_CopyScanline(BitmapScaler *This,
 192     UINT dst_x, UINT dst_y, UINT dst_width,
 193     BYTE **src_data, UINT src_data_x, UINT src_data_y, BYTE *pbBuffer)
 194 {
 195     UINT i;
 196     UINT bytesperpixel = This->bpp/8;
 197     UINT src_x, src_y;
 198
 199     src_y = dst_y * This->src_height / This->height - src_data_y;
 200
 201     for (i=0; i<dst_width; i++)
 202     {
 203         src_x = (dst_x + i) * This->src_width / This->width - src_data_x;
 204         memcpy(pbBuffer + bytesperpixel * i, src_data[src_y] + bytesperpixel * src_x, bytesperpixel);
 205     }
 206 }
 207
 208 static HRESULT WINAPI BitmapScaler_CopyPixels(IWICBitmapScaler *iface,
 209     const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 210 {
 211     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
 212     HRESULT hr;
 213     WICRect dest_rect;
 214     WICRect src_rect_ul, src_rect_br, src_rect;
 215     BYTE **src_rows;
 216     BYTE *src_bits;
 217     ULONG bytesperrow;
 218     ULONG src_bytesperrow;
 219     ULONG buffer_size;
 220     UINT y;
 221
 222     TRACE("(%p,%s,%u,%u,%p)\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
 223
 224     EnterCriticalSection(&This->lock);
 225
 226     if (!This->source)
 227     {
 228         hr = WINCODEC_ERR_NOTINITIALIZED;
 229         goto end;
 230     }
 231
 232     if (prc)
 233         dest_rect = *prc;
 234     else
 235     {
 236         dest_rect.X = dest_rect.Y = 0;
 237         dest_rect.Width = This->width;
 238         dest_rect.Height = This->height;
 239     }
 240
 241     if (dest_rect.X < 0 || dest_rect.Y < 0 ||
 242         dest_rect.X+dest_rect.Width > This->width|| dest_rect.Y+dest_rect.Height > This->height)
 243     {
 244         hr = E_INVALIDARG;
 245         goto end;
 246     }
 247
 248     bytesperrow = ((This->bpp * dest_rect.Width)+7)/8;
 249
 250     if (cbStride < bytesperrow)
 251     {
 252         hr = E_INVALIDARG;
 253         goto end;
 254     }
 255
 256     if ((cbStride * dest_rect.Height) > cbBufferSize)
 257     {
 258         hr = E_INVALIDARG;
 259         goto end;
 260     }
 261
 262     /* MSDN recommends calling CopyPixels once for each scanline from top to
 263      * bottom, and claims codecs optimize for this. Ideally, when called in this
 264      * way, we should avoid requesting a scanline from the source more than
 265      * once, by saving the data that will be useful for the next scanline after
 266      * the call returns. The GetRequiredSourceRect/CopyScanline functions are
 267      * designed to make it possible to do this in a generic way, but for now we
 268      * just grab all the data we need in each call. */
 269
 270     This->fn_get_required_source_rect(This, dest_rect.X, dest_rect.Y, &src_rect_ul);
 271     This->fn_get_required_source_rect(This, dest_rect.X+dest_rect.Width-1,
 272         dest_rect.Y+dest_rect.Height-1, &src_rect_br);
 273
 274     src_rect.X = src_rect_ul.X;
 275     src_rect.Y = src_rect_ul.Y;
 276     src_rect.Width = src_rect_br.Width + src_rect_br.X - src_rect_ul.X;
 277     src_rect.Height = src_rect_br.Height + src_rect_br.Y - src_rect_ul.Y;
 278
 279     src_bytesperrow = (src_rect.Width * This->bpp + 7)/8;
 280     buffer_size = src_bytesperrow * src_rect.Height;
 281
 282     src_rows = HeapAlloc(GetProcessHeap(), 0, sizeof(BYTE*) * src_rect.Height);
 283     src_bits = HeapAlloc(GetProcessHeap(), 0, buffer_size);
 284
 285     if (!src_rows || !src_bits)
 286     {
 287         HeapFree(GetProcessHeap(), 0, src_rows);
 288         HeapFree(GetProcessHeap(), 0, src_bits);
 289         hr = E_OUTOFMEMORY;
 290         goto end;
 291     }
 292
 293     for (y=0; y<src_rect.Height; y++)
 294         src_rows[y] = src_bits + y * src_bytesperrow;
 295
 296     hr = IWICBitmapSource_CopyPixels(This->source, &src_rect, src_bytesperrow,
 297         buffer_size, src_bits);
 298
 299     if (SUCCEEDED(hr))
 300     {
 301         for (y=0; y < dest_rect.Height; y++)
 302         {
 303             This->fn_copy_scanline(This, dest_rect.X, dest_rect.Y+y, dest_rect.Width,
 304                 src_rows, src_rect.X, src_rect.Y, pbBuffer + cbStride * y);
 305         }
 306     }
 307
 308     HeapFree(GetProcessHeap(), 0, src_rows);
 309     HeapFree(GetProcessHeap(), 0, src_bits);
 310
 311 end:
 312     LeaveCriticalSection(&This->lock);
 313
 314     return hr;
 315 }
 316
 317 static HRESULT WINAPI BitmapScaler_Initialize(IWICBitmapScaler *iface,
 318     IWICBitmapSource *pISource, UINT uiWidth, UINT uiHeight,
 319     WICBitmapInterpolationMode mode)
 320 {
 321     BitmapScaler *This = impl_from_IWICBitmapScaler(iface);
 322     HRESULT hr;
 323     GUID src_pixelformat;
 324
 325     TRACE("(%p,%p,%u,%u,%u)\n", iface, pISource, uiWidth, uiHeight, mode);
 326
 327     if (!pISource || !uiWidth || !uiHeight)
 328         return E_INVALIDARG;
 329
 330     EnterCriticalSection(&This->lock);
 331
 332     if (This->source)
 333     {
 334         hr = WINCODEC_ERR_WRONGSTATE;
 335         goto end;
 336     }
 337
 338     This->width = uiWidth;
 339     This->height = uiHeight;
 340     This->mode = mode;
 341
 342     hr = IWICBitmapSource_GetSize(pISource, &This->src_width, &This->src_height);
 343
 344     if (SUCCEEDED(hr))
 345         hr = IWICBitmapSource_GetPixelFormat(pISource, &src_pixelformat);
 346
 347     if (SUCCEEDED(hr))
 348     {
 349         hr = get_pixelformat_bpp(&src_pixelformat, &This->bpp);
 350     }
 351
 352     if (SUCCEEDED(hr))
 353     {
 354         switch (mode)
 355         {
 356         default:
 357             FIXME("unsupported mode %i\n", mode);
 358             /* fall-through */
 359         case WICBitmapInterpolationModeNearestNeighbor:
 360             if ((This->bpp % 8) == 0)
 361             {
 362                 IWICBitmapSource_AddRef(pISource);
 363                 This->source = pISource;
 364             }
 365             else
 366             {
 367                 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA,
 368                     pISource, &This->source);
 369                 This->bpp = 32;
 370             }
 371             This->fn_get_required_source_rect = NearestNeighbor_GetRequiredSourceRect;
 372             This->fn_copy_scanline = NearestNeighbor_CopyScanline;
 373             break;
 374         }
 375     }
 376
 377 end:
 378     LeaveCriticalSection(&This->lock);
 379
 380     return hr;
 381 }
 382
 383 static const IWICBitmapScalerVtbl BitmapScaler_Vtbl = {
 384     BitmapScaler_QueryInterface,
 385     BitmapScaler_AddRef,
 386     BitmapScaler_Release,
 387     BitmapScaler_GetSize,
 388     BitmapScaler_GetPixelFormat,
 389     BitmapScaler_GetResolution,
 390     BitmapScaler_CopyPalette,
 391     BitmapScaler_CopyPixels,
 392     BitmapScaler_Initialize
 393 };
 394
 395 static HRESULT WINAPI IMILBitmapScaler_QueryInterface(IMILBitmapScaler *iface, REFIID iid,
 396     void **ppv)
 397 {
 398     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 399     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 400     return IWICBitmapScaler_QueryInterface(&This->IWICBitmapScaler_iface, iid, ppv);
 401 }
 402
 403 static ULONG WINAPI IMILBitmapScaler_AddRef(IMILBitmapScaler *iface)
 404 {
 405     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 406     return IWICBitmapScaler_AddRef(&This->IWICBitmapScaler_iface);
 407 }
 408
 409 static ULONG WINAPI IMILBitmapScaler_Release(IMILBitmapScaler *iface)
 410 {
 411     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 412     return IWICBitmapScaler_Release(&This->IWICBitmapScaler_iface);
 413 }
 414
 415 static HRESULT WINAPI IMILBitmapScaler_GetSize(IMILBitmapScaler *iface,
 416     UINT *width, UINT *height)
 417 {
 418     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 419     TRACE("(%p,%p,%p)\n", iface, width, height);
 420     return IWICBitmapScaler_GetSize(&This->IWICBitmapScaler_iface, width, height);
 421 }
 422
 423 static HRESULT WINAPI IMILBitmapScaler_GetPixelFormat(IMILBitmapScaler *iface,
 424     int *format)
 425 {
 426     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 427     IMILBitmapSource *source;
 428     HRESULT hr;
 429
 430     TRACE("(%p,%p)\n", iface, format);
 431
 432     if (!format) return E_INVALIDARG;
 433
 434     if (!This->source)
 435         return WINCODEC_ERR_NOTINITIALIZED;
 436
 437     hr = IWICBitmapSource_QueryInterface(This->source, &IID_IMILBitmapSource, (void **)&source);
 438     if (hr == S_OK)
 439     {
 440         hr = source->lpVtbl->GetPixelFormat(source, format);
 441         source->lpVtbl->Release(source);
 442     }
 443     return hr;
 444 }
 445
 446 static HRESULT WINAPI IMILBitmapScaler_GetResolution(IMILBitmapScaler *iface,
 447     double *dpix, double *dpiy)
 448 {
 449     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 450     TRACE("(%p,%p,%p)\n", iface, dpix, dpiy);
 451     return IWICBitmapScaler_GetResolution(&This->IWICBitmapScaler_iface, dpix, dpiy);
 452 }
 453
 454 static HRESULT WINAPI IMILBitmapScaler_CopyPalette(IMILBitmapScaler *iface,
 455     IWICPalette *palette)
 456 {
 457     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 458
 459     TRACE("(%p,%p)\n", iface, palette);
 460
 461     if (!This->source)
 462         return WINCODEC_ERR_NOTINITIALIZED;
 463
 464     return IWICBitmapScaler_CopyPalette(&This->IWICBitmapScaler_iface, palette);
 465 }
 466
 467 static HRESULT WINAPI IMILBitmapScaler_CopyPixels(IMILBitmapScaler *iface,
 468     const WICRect *rc, UINT stride, UINT size, BYTE *buffer)
 469 {
 470     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 471     TRACE("(%p,%p,%u,%u,%p)\n", iface, rc, stride, size, buffer);
 472     return IWICBitmapScaler_CopyPixels(&This->IWICBitmapScaler_iface, rc, stride, size, buffer);
 473 }
 474
 475 static HRESULT WINAPI IMILBitmapScaler_unknown1(IMILBitmapScaler *iface, void **ppv)
 476 {
 477     TRACE("(%p,%p)\n", iface, ppv);
 478     return E_NOINTERFACE;
 479 }
 480
 481 static HRESULT WINAPI IMILBitmapScaler_Initialize(IMILBitmapScaler *iface,
 482     IMILBitmapSource *mil_source, UINT width, UINT height,
 483     WICBitmapInterpolationMode mode)
 484 {
 485     BitmapScaler *This = impl_from_IMILBitmapScaler(iface);
 486     IWICBitmapSource *wic_source;
 487     HRESULT hr;
 488
 489     TRACE("(%p,%p,%u,%u,%u)\n", iface, mil_source, width, height, mode);
 490
 491     if (!mil_source) return E_INVALIDARG;
 492
 493     hr = mil_source->lpVtbl->QueryInterface(mil_source, &IID_IWICBitmapSource, (void **)&wic_source);
 494     if (hr == S_OK)
 495     {
 496         hr = IWICBitmapScaler_Initialize(&This->IWICBitmapScaler_iface, wic_source, width, height, mode);
 497         IWICBitmapSource_Release(wic_source);
 498     }
 499     return hr;
 500 }
 501
 502 static const IMILBitmapScalerVtbl IMILBitmapScaler_Vtbl = {
 503     IMILBitmapScaler_QueryInterface,
 504     IMILBitmapScaler_AddRef,
 505     IMILBitmapScaler_Release,
 506     IMILBitmapScaler_GetSize,
 507     IMILBitmapScaler_GetPixelFormat,
 508     IMILBitmapScaler_GetResolution,
 509     IMILBitmapScaler_CopyPalette,
 510     IMILBitmapScaler_CopyPixels,
 511     IMILBitmapScaler_unknown1,
 512     IMILBitmapScaler_Initialize
 513 };
 514
 515 HRESULT BitmapScaler_Create(IWICBitmapScaler **scaler)
 516 {
 517     BitmapScaler *This;
 518
 519     This = HeapAlloc(GetProcessHeap(), 0, sizeof(BitmapScaler));
 520     if (!This) return E_OUTOFMEMORY;
 521
 522     This->IWICBitmapScaler_iface.lpVtbl = &BitmapScaler_Vtbl;
 523     This->IMILBitmapScaler_iface.lpVtbl = &IMILBitmapScaler_Vtbl;
 524     This->ref = 1;
 525     This->source = NULL;
 526     This->width = 0;
 527     This->height = 0;
 528     This->src_width = 0;
 529     This->src_height = 0;
 530     This->mode = 0;
 531     This->bpp = 0;
 532     InitializeCriticalSection(&This->lock);
 533     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BitmapScaler.lock");
 534
 535     *scaler = &This->IWICBitmapScaler_iface;
 536
 537     return S_OK;
 538 }