reactos/dll/win32/windowscodecs/scaler.c

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