dlls/mfplat/buffer.c

   1 /*
   2  * Copyright 2018 Alistair Leslie-Hughes
   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 #define COBJMACROS
  20
  21 #include <malloc.h>
  22
  23 #include "mfplat_private.h"
  24 #include "rtworkq.h"
  25
  26 #include "d3d11.h"
  27 #include "initguid.h"
  28 #include "d3d9.h"
  29 #include "evr.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  32
  33 #define ALIGN_SIZE(size, alignment) (((size) + (alignment)) & ~((alignment)))
  34
  35 typedef void (*p_copy_image_func)(BYTE *dest, LONG dest_stride, const BYTE *src, LONG src_stride, DWORD width, DWORD lines);
  36
  37 struct buffer
  38 {
  39     IMFMediaBuffer IMFMediaBuffer_iface;
  40     IMF2DBuffer2 IMF2DBuffer2_iface;
  41     IMFDXGIBuffer IMFDXGIBuffer_iface;
  42     IMFGetService IMFGetService_iface;
  43     LONG refcount;
  44
  45     BYTE *data;
  46     DWORD max_length;
  47     DWORD current_length;
  48
  49     struct
  50     {
  51         BYTE *linear_buffer;
  52         DWORD plane_size;
  53
  54         BYTE *scanline0;
  55         unsigned int width;
  56         unsigned int height;
  57         int pitch;
  58         unsigned int locks;
  59         p_copy_image_func copy_image;
  60     } _2d;
  61     struct
  62     {
  63         IDirect3DSurface9 *surface;
  64         D3DLOCKED_RECT rect;
  65     } d3d9_surface;
  66     struct
  67     {
  68         ID3D11Texture2D *texture;
  69         unsigned int sub_resource_idx;
  70         ID3D11Texture2D *rb_texture;
  71         D3D11_MAPPED_SUBRESOURCE map_desc;
  72         struct attributes attributes;
  73     } dxgi_surface;
  74
  75     CRITICAL_SECTION cs;
  76 };
  77
  78 static void copy_image(const struct buffer *buffer, BYTE *dest, LONG dest_stride, const BYTE *src,
  79         LONG src_stride, DWORD width, DWORD lines)
  80 {
  81     MFCopyImage(dest, dest_stride, src, src_stride, width, lines);
  82
  83     if (buffer->_2d.copy_image)
  84     {
  85         dest += dest_stride * lines;
  86         src += src_stride * lines;
  87         buffer->_2d.copy_image(dest, dest_stride, src, src_stride, width, lines);
  88     }
  89 }
  90
  91 static void copy_image_nv12(BYTE *dest, LONG dest_stride, const BYTE *src, LONG src_stride, DWORD width, DWORD lines)
  92 {
  93     MFCopyImage(dest, dest_stride, src, src_stride, width, lines / 2);
  94 }
  95
  96 static void copy_image_imc1(BYTE *dest, LONG dest_stride, const BYTE *src, LONG src_stride, DWORD width, DWORD lines)
  97 {
  98     MFCopyImage(dest, dest_stride, src, src_stride, width / 2, lines);
  99 }
 100
 101 static void copy_image_imc2(BYTE *dest, LONG dest_stride, const BYTE *src, LONG src_stride, DWORD width, DWORD lines)
 102 {
 103     MFCopyImage(dest, dest_stride, src, src_stride, width / 2, lines / 2);
 104     MFCopyImage(dest + dest_stride / 2, dest_stride, src + src_stride / 2, src_stride, width / 2, lines / 2);
 105 }
 106
 107 static inline struct buffer *impl_from_IMFMediaBuffer(IMFMediaBuffer *iface)
 108 {
 109     return CONTAINING_RECORD(iface, struct buffer, IMFMediaBuffer_iface);
 110 }
 111
 112 static struct buffer *impl_from_IMF2DBuffer2(IMF2DBuffer2 *iface)
 113 {
 114     return CONTAINING_RECORD(iface, struct buffer, IMF2DBuffer2_iface);
 115 }
 116
 117 static struct buffer *impl_from_IMFGetService(IMFGetService *iface)
 118 {
 119     return CONTAINING_RECORD(iface, struct buffer, IMFGetService_iface);
 120 }
 121
 122 static struct buffer *impl_from_IMFDXGIBuffer(IMFDXGIBuffer *iface)
 123 {
 124     return CONTAINING_RECORD(iface, struct buffer, IMFDXGIBuffer_iface);
 125 }
 126
 127 static HRESULT WINAPI memory_buffer_QueryInterface(IMFMediaBuffer *iface, REFIID riid, void **out)
 128 {
 129     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 130
 131     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 132
 133     if (IsEqualIID(riid, &IID_IMFMediaBuffer) ||
 134             IsEqualIID(riid, &IID_IUnknown))
 135     {
 136         *out = &buffer->IMFMediaBuffer_iface;
 137         IMFMediaBuffer_AddRef(iface);
 138         return S_OK;
 139     }
 140
 141     WARN("Unsupported %s.\n", debugstr_guid(riid));
 142     *out = NULL;
 143     return E_NOINTERFACE;
 144 }
 145
 146 static ULONG WINAPI memory_buffer_AddRef(IMFMediaBuffer *iface)
 147 {
 148     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 149     ULONG refcount = InterlockedIncrement(&buffer->refcount);
 150
 151     TRACE("%p, refcount %lu.\n", buffer, refcount);
 152
 153     return refcount;
 154 }
 155
 156 static ULONG WINAPI memory_buffer_Release(IMFMediaBuffer *iface)
 157 {
 158     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 159     ULONG refcount = InterlockedDecrement(&buffer->refcount);
 160
 161     TRACE("%p, refcount %lu.\n", iface, refcount);
 162
 163     if (!refcount)
 164     {
 165         if (buffer->d3d9_surface.surface)
 166             IDirect3DSurface9_Release(buffer->d3d9_surface.surface);
 167         if (buffer->dxgi_surface.texture)
 168         {
 169             ID3D11Texture2D_Release(buffer->dxgi_surface.texture);
 170             if (buffer->dxgi_surface.rb_texture)
 171                 ID3D11Texture2D_Release(buffer->dxgi_surface.rb_texture);
 172             clear_attributes_object(&buffer->dxgi_surface.attributes);
 173         }
 174         DeleteCriticalSection(&buffer->cs);
 175         free(buffer->_2d.linear_buffer);
 176         _aligned_free(buffer->data);
 177         free(buffer);
 178     }
 179
 180     return refcount;
 181 }
 182
 183 static HRESULT WINAPI memory_buffer_Lock(IMFMediaBuffer *iface, BYTE **data, DWORD *max_length, DWORD *current_length)
 184 {
 185     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 186
 187     TRACE("%p, %p %p, %p.\n", iface, data, max_length, current_length);
 188
 189     if (!data)
 190         return E_INVALIDARG;
 191
 192     *data = buffer->data;
 193     if (max_length)
 194         *max_length = buffer->max_length;
 195     if (current_length)
 196         *current_length = buffer->current_length;
 197
 198     return S_OK;
 199 }
 200
 201 static HRESULT WINAPI memory_buffer_Unlock(IMFMediaBuffer *iface)
 202 {
 203     TRACE("%p.\n", iface);
 204
 205     return S_OK;
 206 }
 207
 208 static HRESULT WINAPI memory_buffer_GetCurrentLength(IMFMediaBuffer *iface, DWORD *current_length)
 209 {
 210     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 211
 212     TRACE("%p.\n", iface);
 213
 214     if (!current_length)
 215         return E_INVALIDARG;
 216
 217     *current_length = buffer->current_length;
 218
 219     return S_OK;
 220 }
 221
 222 static HRESULT WINAPI memory_buffer_SetCurrentLength(IMFMediaBuffer *iface, DWORD current_length)
 223 {
 224     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 225
 226     TRACE("%p, %lu.\n", iface, current_length);
 227
 228     if (current_length > buffer->max_length)
 229         return E_INVALIDARG;
 230
 231     buffer->current_length = current_length;
 232
 233     return S_OK;
 234 }
 235
 236 static HRESULT WINAPI memory_buffer_GetMaxLength(IMFMediaBuffer *iface, DWORD *max_length)
 237 {
 238     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 239
 240     TRACE("%p, %p.\n", iface, max_length);
 241
 242     if (!max_length)
 243         return E_INVALIDARG;
 244
 245     *max_length = buffer->max_length;
 246
 247     return S_OK;
 248 }
 249
 250 static const IMFMediaBufferVtbl memory_1d_buffer_vtbl =
 251 {
 252     memory_buffer_QueryInterface,
 253     memory_buffer_AddRef,
 254     memory_buffer_Release,
 255     memory_buffer_Lock,
 256     memory_buffer_Unlock,
 257     memory_buffer_GetCurrentLength,
 258     memory_buffer_SetCurrentLength,
 259     memory_buffer_GetMaxLength,
 260 };
 261
 262 static HRESULT WINAPI memory_1d_2d_buffer_QueryInterface(IMFMediaBuffer *iface, REFIID riid, void **out)
 263 {
 264     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 265
 266     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 267
 268     if (IsEqualIID(riid, &IID_IMFMediaBuffer) ||
 269             IsEqualIID(riid, &IID_IUnknown))
 270     {
 271         *out = &buffer->IMFMediaBuffer_iface;
 272     }
 273     else if (IsEqualIID(riid, &IID_IMF2DBuffer2) ||
 274             IsEqualIID(riid, &IID_IMF2DBuffer))
 275     {
 276         *out = &buffer->IMF2DBuffer2_iface;
 277     }
 278     else if (IsEqualIID(riid, &IID_IMFGetService))
 279     {
 280         *out = &buffer->IMFGetService_iface;
 281     }
 282     else
 283     {
 284         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 285         *out = NULL;
 286         return E_NOINTERFACE;
 287     }
 288
 289     IUnknown_AddRef((IUnknown*)*out);
 290     return S_OK;
 291 }
 292
 293 static HRESULT WINAPI memory_1d_2d_buffer_Lock(IMFMediaBuffer *iface, BYTE **data, DWORD *max_length, DWORD *current_length)
 294 {
 295     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 296     HRESULT hr = S_OK;
 297
 298     TRACE("%p, %p, %p, %p.\n", iface, data, max_length, current_length);
 299
 300     if (!data)
 301         return E_POINTER;
 302
 303     /* Allocate linear buffer and return it as a copy of current content. Maximum and current length are
 304        unrelated to 2D buffer maximum allocate length, or maintained current length. */
 305
 306     EnterCriticalSection(&buffer->cs);
 307
 308     if (!buffer->_2d.linear_buffer && buffer->_2d.locks)
 309         hr = MF_E_INVALIDREQUEST;
 310     else if (!buffer->_2d.linear_buffer)
 311     {
 312         if (!(buffer->_2d.linear_buffer = malloc(buffer->_2d.plane_size)))
 313             hr = E_OUTOFMEMORY;
 314
 315         if (SUCCEEDED(hr))
 316             copy_image(buffer, buffer->_2d.linear_buffer, buffer->_2d.width, buffer->data, buffer->_2d.pitch,
 317                     buffer->_2d.width, buffer->_2d.height);
 318     }
 319
 320     if (SUCCEEDED(hr))
 321     {
 322         ++buffer->_2d.locks;
 323         *data = buffer->_2d.linear_buffer;
 324         if (max_length)
 325             *max_length = buffer->_2d.plane_size;
 326         if (current_length)
 327             *current_length = buffer->_2d.plane_size;
 328     }
 329
 330     LeaveCriticalSection(&buffer->cs);
 331
 332     return hr;
 333 }
 334
 335 static HRESULT WINAPI memory_1d_2d_buffer_Unlock(IMFMediaBuffer *iface)
 336 {
 337     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 338
 339     TRACE("%p.\n", iface);
 340
 341     EnterCriticalSection(&buffer->cs);
 342
 343     if (buffer->_2d.linear_buffer && !--buffer->_2d.locks)
 344     {
 345         copy_image(buffer, buffer->data, buffer->_2d.pitch, buffer->_2d.linear_buffer, buffer->_2d.width,
 346                 buffer->_2d.width, buffer->_2d.height);
 347
 348         free(buffer->_2d.linear_buffer);
 349         buffer->_2d.linear_buffer = NULL;
 350     }
 351
 352     LeaveCriticalSection(&buffer->cs);
 353
 354     return S_OK;
 355 }
 356
 357 static const IMFMediaBufferVtbl memory_1d_2d_buffer_vtbl =
 358 {
 359     memory_1d_2d_buffer_QueryInterface,
 360     memory_buffer_AddRef,
 361     memory_buffer_Release,
 362     memory_1d_2d_buffer_Lock,
 363     memory_1d_2d_buffer_Unlock,
 364     memory_buffer_GetCurrentLength,
 365     memory_buffer_SetCurrentLength,
 366     memory_buffer_GetMaxLength,
 367 };
 368
 369 static HRESULT WINAPI d3d9_surface_buffer_Lock(IMFMediaBuffer *iface, BYTE **data, DWORD *max_length, DWORD *current_length)
 370 {
 371     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 372     HRESULT hr = S_OK;
 373
 374     TRACE("%p, %p, %p, %p.\n", iface, data, max_length, current_length);
 375
 376     if (!data)
 377         return E_POINTER;
 378
 379     EnterCriticalSection(&buffer->cs);
 380
 381     if (!buffer->_2d.linear_buffer && buffer->_2d.locks)
 382         hr = MF_E_INVALIDREQUEST;
 383     else if (!buffer->_2d.linear_buffer)
 384     {
 385         D3DLOCKED_RECT rect;
 386
 387         if (!(buffer->_2d.linear_buffer = malloc(buffer->_2d.plane_size)))
 388             hr = E_OUTOFMEMORY;
 389
 390         if (SUCCEEDED(hr))
 391         {
 392             hr = IDirect3DSurface9_LockRect(buffer->d3d9_surface.surface, &rect, NULL, 0);
 393             if (SUCCEEDED(hr))
 394             {
 395                 copy_image(buffer, buffer->_2d.linear_buffer, buffer->_2d.width, rect.pBits, rect.Pitch,
 396                         buffer->_2d.width, buffer->_2d.height);
 397                 IDirect3DSurface9_UnlockRect(buffer->d3d9_surface.surface);
 398             }
 399         }
 400     }
 401
 402     if (SUCCEEDED(hr))
 403     {
 404         ++buffer->_2d.locks;
 405         *data = buffer->_2d.linear_buffer;
 406         if (max_length)
 407             *max_length = buffer->_2d.plane_size;
 408         if (current_length)
 409             *current_length = buffer->_2d.plane_size;
 410     }
 411
 412     LeaveCriticalSection(&buffer->cs);
 413
 414     return hr;
 415 }
 416
 417 static HRESULT WINAPI d3d9_surface_buffer_Unlock(IMFMediaBuffer *iface)
 418 {
 419     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 420     HRESULT hr = S_OK;
 421
 422     TRACE("%p.\n", iface);
 423
 424     EnterCriticalSection(&buffer->cs);
 425
 426     if (!buffer->_2d.linear_buffer)
 427         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
 428     else if (!--buffer->_2d.locks)
 429     {
 430         D3DLOCKED_RECT rect;
 431
 432         if (SUCCEEDED(hr = IDirect3DSurface9_LockRect(buffer->d3d9_surface.surface, &rect, NULL, 0)))
 433         {
 434             copy_image(buffer, rect.pBits, rect.Pitch, buffer->_2d.linear_buffer, buffer->_2d.width,
 435                     buffer->_2d.width, buffer->_2d.height);
 436             IDirect3DSurface9_UnlockRect(buffer->d3d9_surface.surface);
 437         }
 438
 439         free(buffer->_2d.linear_buffer);
 440         buffer->_2d.linear_buffer = NULL;
 441     }
 442
 443     LeaveCriticalSection(&buffer->cs);
 444
 445     return hr;
 446 }
 447
 448 static HRESULT WINAPI d3d9_surface_buffer_SetCurrentLength(IMFMediaBuffer *iface, DWORD current_length)
 449 {
 450     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 451
 452     TRACE("%p, %lu.\n", iface, current_length);
 453
 454     buffer->current_length = current_length;
 455
 456     return S_OK;
 457 }
 458
 459 static const IMFMediaBufferVtbl d3d9_surface_1d_buffer_vtbl =
 460 {
 461     memory_1d_2d_buffer_QueryInterface,
 462     memory_buffer_AddRef,
 463     memory_buffer_Release,
 464     d3d9_surface_buffer_Lock,
 465     d3d9_surface_buffer_Unlock,
 466     memory_buffer_GetCurrentLength,
 467     d3d9_surface_buffer_SetCurrentLength,
 468     memory_buffer_GetMaxLength,
 469 };
 470
 471 static HRESULT WINAPI memory_2d_buffer_QueryInterface(IMF2DBuffer2 *iface, REFIID riid, void **obj)
 472 {
 473     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 474     return IMFMediaBuffer_QueryInterface(&buffer->IMFMediaBuffer_iface, riid, obj);
 475 }
 476
 477 static ULONG WINAPI memory_2d_buffer_AddRef(IMF2DBuffer2 *iface)
 478 {
 479     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 480     return IMFMediaBuffer_AddRef(&buffer->IMFMediaBuffer_iface);
 481 }
 482
 483 static ULONG WINAPI memory_2d_buffer_Release(IMF2DBuffer2 *iface)
 484 {
 485     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 486     return IMFMediaBuffer_Release(&buffer->IMFMediaBuffer_iface);
 487 }
 488
 489 static HRESULT memory_2d_buffer_lock(struct buffer *buffer, BYTE **scanline0, LONG *pitch,
 490         BYTE **buffer_start, DWORD *buffer_length)
 491 {
 492     HRESULT hr = S_OK;
 493
 494     if (buffer->_2d.linear_buffer)
 495         hr = MF_E_UNEXPECTED;
 496     else
 497     {
 498         ++buffer->_2d.locks;
 499         *scanline0 = buffer->_2d.scanline0;
 500         *pitch = buffer->_2d.pitch;
 501         if (buffer_start)
 502             *buffer_start = buffer->data;
 503         if (buffer_length)
 504             *buffer_length = buffer->max_length;
 505     }
 506
 507     return hr;
 508 }
 509
 510 static HRESULT WINAPI memory_2d_buffer_Lock2D(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
 511 {
 512     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 513     HRESULT hr;
 514
 515     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
 516
 517     if (!scanline0 || !pitch)
 518         return E_POINTER;
 519
 520     EnterCriticalSection(&buffer->cs);
 521
 522     hr = memory_2d_buffer_lock(buffer, scanline0, pitch, NULL, NULL);
 523
 524     LeaveCriticalSection(&buffer->cs);
 525
 526     return hr;
 527 }
 528
 529 static HRESULT WINAPI memory_2d_buffer_Unlock2D(IMF2DBuffer2 *iface)
 530 {
 531     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 532     HRESULT hr = S_OK;
 533
 534     TRACE("%p.\n", iface);
 535
 536     EnterCriticalSection(&buffer->cs);
 537
 538     if (!buffer->_2d.linear_buffer)
 539     {
 540         if (buffer->_2d.locks)
 541             --buffer->_2d.locks;
 542         else
 543             hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
 544     }
 545
 546     LeaveCriticalSection(&buffer->cs);
 547
 548     return hr;
 549 }
 550
 551 static HRESULT WINAPI memory_2d_buffer_GetScanline0AndPitch(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
 552 {
 553     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 554     HRESULT hr = S_OK;
 555
 556     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
 557
 558     if (!scanline0 || !pitch)
 559         return E_POINTER;
 560
 561     EnterCriticalSection(&buffer->cs);
 562
 563     if (buffer->_2d.linear_buffer || !buffer->_2d.locks)
 564         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
 565     else
 566     {
 567         *scanline0 = buffer->_2d.scanline0;
 568         *pitch = buffer->_2d.pitch;
 569     }
 570
 571     LeaveCriticalSection(&buffer->cs);
 572
 573     return hr;
 574 }
 575
 576 static HRESULT WINAPI memory_2d_buffer_IsContiguousFormat(IMF2DBuffer2 *iface, BOOL *is_contiguous)
 577 {
 578     TRACE("%p, %p.\n", iface, is_contiguous);
 579
 580     if (!is_contiguous)
 581         return E_POINTER;
 582
 583     *is_contiguous = FALSE;
 584
 585     return S_OK;
 586 }
 587
 588 static HRESULT WINAPI memory_2d_buffer_GetContiguousLength(IMF2DBuffer2 *iface, DWORD *length)
 589 {
 590     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 591
 592     TRACE("%p, %p.\n", iface, length);
 593
 594     if (!length)
 595         return E_POINTER;
 596
 597     *length = buffer->_2d.plane_size;
 598
 599     return S_OK;
 600 }
 601
 602 static HRESULT WINAPI memory_2d_buffer_ContiguousCopyTo(IMF2DBuffer2 *iface, BYTE *dest_buffer, DWORD dest_length)
 603 {
 604     FIXME("%p, %p, %lu.\n", iface, dest_buffer, dest_length);
 605
 606     return E_NOTIMPL;
 607 }
 608
 609 static HRESULT WINAPI memory_2d_buffer_ContiguousCopyFrom(IMF2DBuffer2 *iface, const BYTE *src_buffer, DWORD src_length)
 610 {
 611     FIXME("%p, %p, %lu.\n", iface, src_buffer, src_length);
 612
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI memory_2d_buffer_Lock2DSize(IMF2DBuffer2 *iface, MF2DBuffer_LockFlags flags, BYTE **scanline0,
 617         LONG *pitch, BYTE **buffer_start, DWORD *buffer_length)
 618 {
 619     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 620     HRESULT hr;
 621
 622     TRACE("%p, %#x, %p, %p, %p, %p.\n", iface, flags, scanline0, pitch, buffer_start, buffer_length);
 623
 624     if (!scanline0 || !pitch || !buffer_start || !buffer_length)
 625         return E_POINTER;
 626
 627     EnterCriticalSection(&buffer->cs);
 628
 629     hr = memory_2d_buffer_lock(buffer, scanline0, pitch, buffer_start, buffer_length);
 630
 631     LeaveCriticalSection(&buffer->cs);
 632
 633     return hr;
 634 }
 635
 636 static HRESULT WINAPI memory_2d_buffer_Copy2DTo(IMF2DBuffer2 *iface, IMF2DBuffer2 *dest_buffer)
 637 {
 638     FIXME("%p, %p.\n", iface, dest_buffer);
 639
 640     return E_NOTIMPL;
 641 }
 642
 643 static const IMF2DBuffer2Vtbl memory_2d_buffer_vtbl =
 644 {
 645     memory_2d_buffer_QueryInterface,
 646     memory_2d_buffer_AddRef,
 647     memory_2d_buffer_Release,
 648     memory_2d_buffer_Lock2D,
 649     memory_2d_buffer_Unlock2D,
 650     memory_2d_buffer_GetScanline0AndPitch,
 651     memory_2d_buffer_IsContiguousFormat,
 652     memory_2d_buffer_GetContiguousLength,
 653     memory_2d_buffer_ContiguousCopyTo,
 654     memory_2d_buffer_ContiguousCopyFrom,
 655     memory_2d_buffer_Lock2DSize,
 656     memory_2d_buffer_Copy2DTo,
 657 };
 658
 659 static HRESULT WINAPI d3d9_surface_buffer_Lock2D(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
 660 {
 661     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 662     HRESULT hr = S_OK;
 663
 664     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
 665
 666     if (!scanline0 || !pitch)
 667         return E_POINTER;
 668
 669     EnterCriticalSection(&buffer->cs);
 670
 671     if (buffer->_2d.linear_buffer)
 672         hr = MF_E_UNEXPECTED;
 673     else if (!buffer->_2d.locks)
 674     {
 675         hr = IDirect3DSurface9_LockRect(buffer->d3d9_surface.surface, &buffer->d3d9_surface.rect, NULL, 0);
 676     }
 677
 678     if (SUCCEEDED(hr))
 679     {
 680         buffer->_2d.locks++;
 681         *scanline0 = buffer->d3d9_surface.rect.pBits;
 682         *pitch = buffer->d3d9_surface.rect.Pitch;
 683     }
 684
 685     LeaveCriticalSection(&buffer->cs);
 686
 687     return hr;
 688 }
 689
 690 static HRESULT WINAPI d3d9_surface_buffer_Unlock2D(IMF2DBuffer2 *iface)
 691 {
 692     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 693     HRESULT hr = S_OK;
 694
 695     TRACE("%p.\n", iface);
 696
 697     EnterCriticalSection(&buffer->cs);
 698
 699     if (buffer->_2d.locks)
 700     {
 701         if (!--buffer->_2d.locks)
 702         {
 703             IDirect3DSurface9_UnlockRect(buffer->d3d9_surface.surface);
 704             memset(&buffer->d3d9_surface.rect, 0, sizeof(buffer->d3d9_surface.rect));
 705         }
 706     }
 707     else
 708         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
 709
 710     LeaveCriticalSection(&buffer->cs);
 711
 712     return hr;
 713 }
 714
 715 static HRESULT WINAPI d3d9_surface_buffer_GetScanline0AndPitch(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
 716 {
 717     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 718     HRESULT hr = S_OK;
 719
 720     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
 721
 722     if (!scanline0 || !pitch)
 723         return E_POINTER;
 724
 725     EnterCriticalSection(&buffer->cs);
 726
 727     if (!buffer->_2d.locks)
 728     {
 729         *scanline0 = NULL;
 730         *pitch = 0;
 731         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
 732     }
 733     else
 734     {
 735         *scanline0 = buffer->d3d9_surface.rect.pBits;
 736         *pitch = buffer->d3d9_surface.rect.Pitch;
 737     }
 738
 739     LeaveCriticalSection(&buffer->cs);
 740
 741     return hr;
 742 }
 743
 744 static HRESULT WINAPI d3d9_surface_buffer_Lock2DSize(IMF2DBuffer2 *iface, MF2DBuffer_LockFlags flags, BYTE **scanline0,
 745         LONG *pitch, BYTE **buffer_start, DWORD *buffer_length)
 746 {
 747     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 748     HRESULT hr = S_OK;
 749
 750     TRACE("%p, %#x, %p, %p, %p, %p.\n", iface, flags, scanline0, pitch, buffer_start, buffer_length);
 751
 752     if (!scanline0 || !pitch || !buffer_start || !buffer_length)
 753         return E_POINTER;
 754
 755     EnterCriticalSection(&buffer->cs);
 756
 757     if (buffer->_2d.linear_buffer)
 758         hr = MF_E_UNEXPECTED;
 759     else if (!buffer->_2d.locks)
 760     {
 761         hr = IDirect3DSurface9_LockRect(buffer->d3d9_surface.surface, &buffer->d3d9_surface.rect, NULL, 0);
 762     }
 763
 764     if (SUCCEEDED(hr))
 765     {
 766         buffer->_2d.locks++;
 767         *scanline0 = buffer->d3d9_surface.rect.pBits;
 768         *pitch = buffer->d3d9_surface.rect.Pitch;
 769         if (buffer_start)
 770             *buffer_start = *scanline0;
 771         if (buffer_length)
 772             *buffer_length = buffer->d3d9_surface.rect.Pitch * buffer->_2d.height;
 773     }
 774
 775     LeaveCriticalSection(&buffer->cs);
 776
 777     return hr;
 778 }
 779
 780 static const IMF2DBuffer2Vtbl d3d9_surface_buffer_vtbl =
 781 {
 782     memory_2d_buffer_QueryInterface,
 783     memory_2d_buffer_AddRef,
 784     memory_2d_buffer_Release,
 785     d3d9_surface_buffer_Lock2D,
 786     d3d9_surface_buffer_Unlock2D,
 787     d3d9_surface_buffer_GetScanline0AndPitch,
 788     memory_2d_buffer_IsContiguousFormat,
 789     memory_2d_buffer_GetContiguousLength,
 790     memory_2d_buffer_ContiguousCopyTo,
 791     memory_2d_buffer_ContiguousCopyFrom,
 792     d3d9_surface_buffer_Lock2DSize,
 793     memory_2d_buffer_Copy2DTo,
 794 };
 795
 796 static HRESULT WINAPI memory_2d_buffer_gs_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 797 {
 798     struct buffer *buffer = impl_from_IMFGetService(iface);
 799     return IMFMediaBuffer_QueryInterface(&buffer->IMFMediaBuffer_iface, riid, obj);
 800 }
 801
 802 static ULONG WINAPI memory_2d_buffer_gs_AddRef(IMFGetService *iface)
 803 {
 804     struct buffer *buffer = impl_from_IMFGetService(iface);
 805     return IMFMediaBuffer_AddRef(&buffer->IMFMediaBuffer_iface);
 806 }
 807
 808 static ULONG WINAPI memory_2d_buffer_gs_Release(IMFGetService *iface)
 809 {
 810     struct buffer *buffer = impl_from_IMFGetService(iface);
 811     return IMFMediaBuffer_Release(&buffer->IMFMediaBuffer_iface);
 812 }
 813
 814 static HRESULT WINAPI memory_2d_buffer_gs_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 815 {
 816     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 817
 818     return E_NOTIMPL;
 819 }
 820
 821 static const IMFGetServiceVtbl memory_2d_buffer_gs_vtbl =
 822 {
 823     memory_2d_buffer_gs_QueryInterface,
 824     memory_2d_buffer_gs_AddRef,
 825     memory_2d_buffer_gs_Release,
 826     memory_2d_buffer_gs_GetService,
 827 };
 828
 829 static HRESULT WINAPI d3d9_surface_buffer_gs_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 830 {
 831     struct buffer *buffer = impl_from_IMFGetService(iface);
 832
 833     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 834
 835     if (IsEqualGUID(service, &MR_BUFFER_SERVICE))
 836     {
 837         return IDirect3DSurface9_QueryInterface(buffer->d3d9_surface.surface, riid, obj);
 838     }
 839
 840     return E_NOTIMPL;
 841 }
 842
 843 static const IMFGetServiceVtbl d3d9_surface_buffer_gs_vtbl =
 844 {
 845     memory_2d_buffer_gs_QueryInterface,
 846     memory_2d_buffer_gs_AddRef,
 847     memory_2d_buffer_gs_Release,
 848     d3d9_surface_buffer_gs_GetService,
 849 };
 850
 851 static HRESULT WINAPI dxgi_1d_2d_buffer_QueryInterface(IMFMediaBuffer *iface, REFIID riid, void **out)
 852 {
 853     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 854
 855     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 856
 857     if (IsEqualIID(riid, &IID_IMFMediaBuffer) ||
 858             IsEqualIID(riid, &IID_IUnknown))
 859     {
 860         *out = &buffer->IMFMediaBuffer_iface;
 861     }
 862     else if (IsEqualIID(riid, &IID_IMF2DBuffer2) ||
 863             IsEqualIID(riid, &IID_IMF2DBuffer))
 864     {
 865         *out = &buffer->IMF2DBuffer2_iface;
 866     }
 867     else if (IsEqualIID(riid, &IID_IMFDXGIBuffer))
 868     {
 869         *out = &buffer->IMFDXGIBuffer_iface;
 870     }
 871     else
 872     {
 873         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 874         *out = NULL;
 875         return E_NOINTERFACE;
 876     }
 877
 878     IUnknown_AddRef((IUnknown*)*out);
 879     return S_OK;
 880 }
 881
 882 static HRESULT dxgi_surface_buffer_create_readback_texture(struct buffer *buffer)
 883 {
 884     D3D11_TEXTURE2D_DESC texture_desc;
 885     ID3D11Device *device;
 886     HRESULT hr;
 887
 888     if (buffer->dxgi_surface.rb_texture)
 889         return S_OK;
 890
 891     ID3D11Texture2D_GetDevice(buffer->dxgi_surface.texture, &device);
 892
 893     ID3D11Texture2D_GetDesc(buffer->dxgi_surface.texture, &texture_desc);
 894     texture_desc.Usage = D3D11_USAGE_STAGING;
 895     texture_desc.BindFlags = 0;
 896     texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
 897     texture_desc.MiscFlags = 0;
 898     texture_desc.MipLevels = 1;
 899     if (FAILED(hr = ID3D11Device_CreateTexture2D(device, &texture_desc, NULL, &buffer->dxgi_surface.rb_texture)))
 900         WARN("Failed to create readback texture, hr %#lx.\n", hr);
 901
 902     ID3D11Device_Release(device);
 903
 904     return hr;
 905 }
 906
 907 static HRESULT dxgi_surface_buffer_map(struct buffer *buffer)
 908 {
 909     ID3D11DeviceContext *immediate_context;
 910     ID3D11Device *device;
 911     HRESULT hr;
 912
 913     if (FAILED(hr = dxgi_surface_buffer_create_readback_texture(buffer)))
 914         return hr;
 915
 916     ID3D11Texture2D_GetDevice(buffer->dxgi_surface.texture, &device);
 917     ID3D11Device_GetImmediateContext(device, &immediate_context);
 918     ID3D11DeviceContext_CopySubresourceRegion(immediate_context, (ID3D11Resource *)buffer->dxgi_surface.rb_texture,
 919             0, 0, 0, 0, (ID3D11Resource *)buffer->dxgi_surface.texture, buffer->dxgi_surface.sub_resource_idx, NULL);
 920
 921     memset(&buffer->dxgi_surface.map_desc, 0, sizeof(buffer->dxgi_surface.map_desc));
 922     if (FAILED(hr = ID3D11DeviceContext_Map(immediate_context, (ID3D11Resource *)buffer->dxgi_surface.rb_texture,
 923             0, D3D11_MAP_READ_WRITE, 0, &buffer->dxgi_surface.map_desc)))
 924     {
 925         WARN("Failed to map readback texture, hr %#lx.\n", hr);
 926     }
 927
 928     ID3D11DeviceContext_Release(immediate_context);
 929     ID3D11Device_Release(device);
 930
 931     return hr;
 932 }
 933
 934 static void dxgi_surface_buffer_unmap(struct buffer *buffer)
 935 {
 936     ID3D11DeviceContext *immediate_context;
 937     ID3D11Device *device;
 938
 939     ID3D11Texture2D_GetDevice(buffer->dxgi_surface.texture, &device);
 940     ID3D11Device_GetImmediateContext(device, &immediate_context);
 941     ID3D11DeviceContext_Unmap(immediate_context, (ID3D11Resource *)buffer->dxgi_surface.rb_texture, 0);
 942     memset(&buffer->dxgi_surface.map_desc, 0, sizeof(buffer->dxgi_surface.map_desc));
 943
 944     ID3D11DeviceContext_CopySubresourceRegion(immediate_context, (ID3D11Resource *)buffer->dxgi_surface.texture,
 945             buffer->dxgi_surface.sub_resource_idx, 0, 0, 0, (ID3D11Resource *)buffer->dxgi_surface.rb_texture, 0, NULL);
 946
 947     ID3D11DeviceContext_Release(immediate_context);
 948     ID3D11Device_Release(device);
 949 }
 950
 951 static HRESULT WINAPI dxgi_surface_buffer_Lock(IMFMediaBuffer *iface, BYTE **data, DWORD *max_length,
 952         DWORD *current_length)
 953 {
 954     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 955     HRESULT hr = S_OK;
 956
 957     TRACE("%p, %p, %p, %p.\n", iface, data, max_length, current_length);
 958
 959     if (!data)
 960         return E_POINTER;
 961
 962     EnterCriticalSection(&buffer->cs);
 963
 964     if (!buffer->_2d.linear_buffer && buffer->_2d.locks)
 965         hr = MF_E_INVALIDREQUEST;
 966     else if (!buffer->_2d.linear_buffer)
 967     {
 968         if (!(buffer->_2d.linear_buffer = malloc(buffer->_2d.plane_size)))
 969             hr = E_OUTOFMEMORY;
 970
 971         if (SUCCEEDED(hr))
 972         {
 973             hr = dxgi_surface_buffer_map(buffer);
 974             if (SUCCEEDED(hr))
 975             {
 976                 copy_image(buffer, buffer->_2d.linear_buffer, buffer->_2d.width, buffer->dxgi_surface.map_desc.pData,
 977                         buffer->dxgi_surface.map_desc.RowPitch, buffer->_2d.width, buffer->_2d.height);
 978             }
 979         }
 980     }
 981
 982     if (SUCCEEDED(hr))
 983     {
 984         ++buffer->_2d.locks;
 985         *data = buffer->_2d.linear_buffer;
 986         if (max_length)
 987             *max_length = buffer->_2d.plane_size;
 988         if (current_length)
 989             *current_length = buffer->_2d.plane_size;
 990     }
 991
 992     LeaveCriticalSection(&buffer->cs);
 993
 994     return hr;
 995 }
 996
 997 static HRESULT WINAPI dxgi_surface_buffer_Unlock(IMFMediaBuffer *iface)
 998 {
 999     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
1000     HRESULT hr = S_OK;
1001
1002     TRACE("%p.\n", iface);
1003
1004     EnterCriticalSection(&buffer->cs);
1005
1006     if (!buffer->_2d.linear_buffer)
1007         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
1008     else if (!--buffer->_2d.locks)
1009     {
1010         copy_image(buffer, buffer->dxgi_surface.map_desc.pData, buffer->dxgi_surface.map_desc.RowPitch,
1011                 buffer->_2d.linear_buffer, buffer->_2d.width, buffer->_2d.width, buffer->_2d.height);
1012         dxgi_surface_buffer_unmap(buffer);
1013
1014         free(buffer->_2d.linear_buffer);
1015         buffer->_2d.linear_buffer = NULL;
1016     }
1017
1018     LeaveCriticalSection(&buffer->cs);
1019
1020     return hr;
1021 }
1022
1023 static HRESULT WINAPI dxgi_surface_buffer_SetCurrentLength(IMFMediaBuffer *iface, DWORD current_length)
1024 {
1025     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
1026
1027     TRACE("%p, %lu.\n", iface, current_length);
1028
1029     buffer->current_length = current_length;
1030
1031     return S_OK;
1032 }
1033
1034 static HRESULT WINAPI dxgi_surface_buffer_Lock2D(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
1035 {
1036     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
1037     HRESULT hr = S_OK;
1038
1039     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
1040
1041     if (!scanline0 || !pitch)
1042         return E_POINTER;
1043
1044     EnterCriticalSection(&buffer->cs);
1045
1046     if (buffer->_2d.linear_buffer)
1047         hr = MF_E_UNEXPECTED;
1048     else if (!buffer->_2d.locks++)
1049         hr = dxgi_surface_buffer_map(buffer);
1050
1051     if (SUCCEEDED(hr))
1052     {
1053         *scanline0 = buffer->dxgi_surface.map_desc.pData;
1054         *pitch = buffer->dxgi_surface.map_desc.RowPitch;
1055     }
1056
1057     LeaveCriticalSection(&buffer->cs);
1058
1059     return hr;
1060 }
1061
1062 static HRESULT WINAPI dxgi_surface_buffer_Unlock2D(IMF2DBuffer2 *iface)
1063 {
1064     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
1065     HRESULT hr = S_OK;
1066
1067     TRACE("%p.\n", iface);
1068
1069     EnterCriticalSection(&buffer->cs);
1070
1071     if (buffer->_2d.locks)
1072     {
1073         if (!--buffer->_2d.locks)
1074             dxgi_surface_buffer_unmap(buffer);
1075     }
1076     else
1077         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
1078
1079     LeaveCriticalSection(&buffer->cs);
1080
1081     return hr;
1082 }
1083
1084 static HRESULT WINAPI dxgi_surface_buffer_GetScanline0AndPitch(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
1085 {
1086     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
1087     HRESULT hr = S_OK;
1088
1089     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
1090
1091     if (!scanline0 || !pitch)
1092         return E_POINTER;
1093
1094     EnterCriticalSection(&buffer->cs);
1095
1096     if (!buffer->_2d.locks)
1097     {
1098         *scanline0 = NULL;
1099         *pitch = 0;
1100         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
1101     }
1102     else
1103     {
1104         *scanline0 = buffer->dxgi_surface.map_desc.pData;
1105         *pitch = buffer->dxgi_surface.map_desc.RowPitch;
1106     }
1107
1108     LeaveCriticalSection(&buffer->cs);
1109
1110     return hr;
1111 }
1112
1113 static HRESULT WINAPI dxgi_surface_buffer_Lock2DSize(IMF2DBuffer2 *iface, MF2DBuffer_LockFlags flags,
1114         BYTE **scanline0, LONG *pitch, BYTE **buffer_start, DWORD *buffer_length)
1115 {
1116     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
1117     HRESULT hr = S_OK;
1118
1119     TRACE("%p, %#x, %p, %p, %p, %p.\n", iface, flags, scanline0, pitch, buffer_start, buffer_length);
1120
1121     if (!scanline0 || !pitch || !buffer_start || !buffer_length)
1122         return E_POINTER;
1123
1124     EnterCriticalSection(&buffer->cs);
1125
1126     if (buffer->_2d.linear_buffer)
1127         hr = MF_E_UNEXPECTED;
1128     else if (!buffer->_2d.locks++)
1129         hr = dxgi_surface_buffer_map(buffer);
1130
1131     if (SUCCEEDED(hr))
1132     {
1133         *scanline0 = buffer->dxgi_surface.map_desc.pData;
1134         *pitch = buffer->dxgi_surface.map_desc.RowPitch;
1135         if (buffer_start)
1136             *buffer_start = *scanline0;
1137         if (buffer_length)
1138             *buffer_length = buffer->dxgi_surface.map_desc.RowPitch * buffer->_2d.height;
1139     }
1140
1141     LeaveCriticalSection(&buffer->cs);
1142
1143     return hr;
1144 }
1145
1146 static HRESULT WINAPI dxgi_buffer_QueryInterface(IMFDXGIBuffer *iface, REFIID riid, void **obj)
1147 {
1148     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1149     return IMFMediaBuffer_QueryInterface(&buffer->IMFMediaBuffer_iface, riid, obj);
1150 }
1151
1152 static ULONG WINAPI dxgi_buffer_AddRef(IMFDXGIBuffer *iface)
1153 {
1154     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1155     return IMFMediaBuffer_AddRef(&buffer->IMFMediaBuffer_iface);
1156 }
1157
1158 static ULONG WINAPI dxgi_buffer_Release(IMFDXGIBuffer *iface)
1159 {
1160     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1161     return IMFMediaBuffer_Release(&buffer->IMFMediaBuffer_iface);
1162 }
1163
1164 static HRESULT WINAPI dxgi_buffer_GetResource(IMFDXGIBuffer *iface, REFIID riid, void **obj)
1165 {
1166     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1167
1168     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1169
1170     return ID3D11Texture2D_QueryInterface(buffer->dxgi_surface.texture, riid, obj);
1171 }
1172
1173 static HRESULT WINAPI dxgi_buffer_GetSubresourceIndex(IMFDXGIBuffer *iface, UINT *index)
1174 {
1175     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1176
1177     TRACE("%p, %p.\n", iface, index);
1178
1179     if (!index)
1180         return E_POINTER;
1181
1182     *index = buffer->dxgi_surface.sub_resource_idx;
1183
1184     return S_OK;
1185 }
1186
1187 static HRESULT WINAPI dxgi_buffer_GetUnknown(IMFDXGIBuffer *iface, REFIID guid, REFIID riid, void **object)
1188 {
1189     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1190
1191     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(guid), debugstr_guid(riid), object);
1192
1193     if (attributes_GetUnknown(&buffer->dxgi_surface.attributes, guid, riid, object) == MF_E_ATTRIBUTENOTFOUND)
1194         return MF_E_NOT_FOUND;
1195
1196     return S_OK;
1197 }
1198
1199 static HRESULT WINAPI dxgi_buffer_SetUnknown(IMFDXGIBuffer *iface, REFIID guid, IUnknown *data)
1200 {
1201     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1202     HRESULT hr = S_OK;
1203
1204     TRACE("%p, %s, %p.\n", iface, debugstr_guid(guid), data);
1205
1206     EnterCriticalSection(&buffer->dxgi_surface.attributes.cs);
1207     if (data)
1208     {
1209         if (SUCCEEDED(attributes_GetItem(&buffer->dxgi_surface.attributes, guid, NULL)))
1210             hr = HRESULT_FROM_WIN32(ERROR_OBJECT_ALREADY_EXISTS);
1211         else
1212             hr = attributes_SetUnknown(&buffer->dxgi_surface.attributes, guid, data);
1213     }
1214     else
1215     {
1216         attributes_DeleteItem(&buffer->dxgi_surface.attributes, guid);
1217     }
1218     LeaveCriticalSection(&buffer->dxgi_surface.attributes.cs);
1219
1220     return hr;
1221 }
1222
1223 static const IMFMediaBufferVtbl dxgi_surface_1d_buffer_vtbl =
1224 {
1225     dxgi_1d_2d_buffer_QueryInterface,
1226     memory_buffer_AddRef,
1227     memory_buffer_Release,
1228     dxgi_surface_buffer_Lock,
1229     dxgi_surface_buffer_Unlock,
1230     memory_buffer_GetCurrentLength,
1231     dxgi_surface_buffer_SetCurrentLength,
1232     memory_buffer_GetMaxLength,
1233 };
1234
1235 static const IMF2DBuffer2Vtbl dxgi_surface_buffer_vtbl =
1236 {
1237     memory_2d_buffer_QueryInterface,
1238     memory_2d_buffer_AddRef,
1239     memory_2d_buffer_Release,
1240     dxgi_surface_buffer_Lock2D,
1241     dxgi_surface_buffer_Unlock2D,
1242     dxgi_surface_buffer_GetScanline0AndPitch,
1243     memory_2d_buffer_IsContiguousFormat,
1244     memory_2d_buffer_GetContiguousLength,
1245     memory_2d_buffer_ContiguousCopyTo,
1246     memory_2d_buffer_ContiguousCopyFrom,
1247     dxgi_surface_buffer_Lock2DSize,
1248     memory_2d_buffer_Copy2DTo,
1249 };
1250
1251 static const IMFDXGIBufferVtbl dxgi_buffer_vtbl =
1252 {
1253     dxgi_buffer_QueryInterface,
1254     dxgi_buffer_AddRef,
1255     dxgi_buffer_Release,
1256     dxgi_buffer_GetResource,
1257     dxgi_buffer_GetSubresourceIndex,
1258     dxgi_buffer_GetUnknown,
1259     dxgi_buffer_SetUnknown,
1260 };
1261
1262 static HRESULT memory_buffer_init(struct buffer *buffer, DWORD max_length, DWORD alignment,
1263         const IMFMediaBufferVtbl *vtbl)
1264 {
1265     if (alignment < MF_16_BYTE_ALIGNMENT)
1266         alignment = MF_16_BYTE_ALIGNMENT;
1267     alignment++;
1268
1269     if (alignment & (alignment - 1))
1270     {
1271         alignment--;
1272         alignment |= alignment >> 1;
1273         alignment |= alignment >> 2;
1274         alignment |= alignment >> 4;
1275         alignment |= alignment >> 8;
1276         alignment |= alignment >> 16;
1277         alignment++;
1278     }
1279
1280     if (!(buffer->data = _aligned_malloc(max_length, alignment)))
1281         return E_OUTOFMEMORY;
1282     memset(buffer->data, 0, max_length);
1283
1284     buffer->IMFMediaBuffer_iface.lpVtbl = vtbl;
1285     buffer->refcount = 1;
1286     buffer->max_length = max_length;
1287     buffer->current_length = 0;
1288     InitializeCriticalSection(&buffer->cs);
1289
1290     return S_OK;
1291 }
1292
1293 static HRESULT create_1d_buffer(DWORD max_length, DWORD alignment, IMFMediaBuffer **buffer)
1294 {
1295     struct buffer *object;
1296     HRESULT hr;
1297
1298     if (!buffer)
1299         return E_POINTER;
1300
1301     *buffer = NULL;
1302
1303     if (!(object = calloc(1, sizeof(*object))))
1304         return E_OUTOFMEMORY;
1305
1306     hr = memory_buffer_init(object, max_length, alignment, &memory_1d_buffer_vtbl);
1307     if (FAILED(hr))
1308     {
1309         free(object);
1310         return hr;
1311     }
1312
1313     *buffer = &object->IMFMediaBuffer_iface;
1314
1315     return S_OK;
1316 }
1317
1318 static p_copy_image_func get_2d_buffer_copy_func(DWORD fourcc)
1319 {
1320     if (fourcc == MAKEFOURCC('N','V','1','2'))
1321         return copy_image_nv12;
1322     if (fourcc == MAKEFOURCC('I','M','C','1') || fourcc == MAKEFOURCC('I','M','C','3'))
1323         return copy_image_imc1;
1324     if (fourcc == MAKEFOURCC('I','M','C','2') || fourcc == MAKEFOURCC('I','M','C','4'))
1325         return copy_image_imc2;
1326     return NULL;
1327 }
1328
1329 static HRESULT create_2d_buffer(DWORD width, DWORD height, DWORD fourcc, BOOL bottom_up, IMFMediaBuffer **buffer)
1330 {
1331     unsigned int stride, max_length;
1332     unsigned int row_alignment;
1333     struct buffer *object;
1334     DWORD plane_size;
1335     GUID subtype;
1336     BOOL is_yuv;
1337     HRESULT hr;
1338     int pitch;
1339
1340     if (!buffer)
1341         return E_POINTER;
1342
1343     *buffer = NULL;
1344
1345     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
1346     subtype.Data1 = fourcc;
1347
1348     if (!(stride = mf_format_get_stride(&subtype, width, &is_yuv)))
1349         return MF_E_INVALIDMEDIATYPE;
1350
1351     if (is_yuv && bottom_up)
1352         return MF_E_INVALIDMEDIATYPE;
1353
1354     if (FAILED(hr = MFGetPlaneSize(fourcc, width, height, &plane_size)))
1355         return hr;
1356
1357     if (!(object = calloc(1, sizeof(*object))))
1358         return E_OUTOFMEMORY;
1359
1360     switch (fourcc)
1361     {
1362         case MAKEFOURCC('I','M','C','1'):
1363         case MAKEFOURCC('I','M','C','2'):
1364         case MAKEFOURCC('I','M','C','3'):
1365         case MAKEFOURCC('I','M','C','4'):
1366         case MAKEFOURCC('Y','V','1','2'):
1367             row_alignment = MF_128_BYTE_ALIGNMENT;
1368             break;
1369         default:
1370             row_alignment = MF_64_BYTE_ALIGNMENT;
1371     }
1372
1373     pitch = ALIGN_SIZE(stride, row_alignment);
1374
1375     switch (fourcc)
1376     {
1377         case MAKEFOURCC('I','M','C','1'):
1378         case MAKEFOURCC('I','M','C','3'):
1379             max_length = pitch * height * 2;
1380             plane_size *= 2;
1381             break;
1382         case MAKEFOURCC('N','V','1','2'):
1383         case MAKEFOURCC('Y','V','1','2'):
1384         case MAKEFOURCC('I','M','C','2'):
1385         case MAKEFOURCC('I','M','C','4'):
1386             max_length = pitch * height * 3 / 2;
1387             break;
1388         default:
1389             max_length = pitch * height;
1390     }
1391
1392     if (FAILED(hr = memory_buffer_init(object, max_length, row_alignment, &memory_1d_2d_buffer_vtbl)))
1393     {
1394         free(object);
1395         return hr;
1396     }
1397
1398     object->IMF2DBuffer2_iface.lpVtbl = &memory_2d_buffer_vtbl;
1399     object->IMFGetService_iface.lpVtbl = &memory_2d_buffer_gs_vtbl;
1400     object->_2d.plane_size = plane_size;
1401     object->_2d.width = stride;
1402     object->_2d.height = height;
1403     object->_2d.pitch = bottom_up ? -pitch : pitch;
1404     object->_2d.scanline0 = bottom_up ? object->data + pitch * (object->_2d.height - 1) : object->data;
1405     object->_2d.copy_image = get_2d_buffer_copy_func(fourcc);
1406
1407     *buffer = &object->IMFMediaBuffer_iface;
1408
1409     return S_OK;
1410 }
1411
1412 static HRESULT create_d3d9_surface_buffer(IUnknown *surface, BOOL bottom_up, IMFMediaBuffer **buffer)
1413 {
1414     struct buffer *object;
1415     D3DSURFACE_DESC desc;
1416     unsigned int stride;
1417     GUID subtype;
1418     BOOL is_yuv;
1419
1420     IDirect3DSurface9_GetDesc((IDirect3DSurface9 *)surface, &desc);
1421     TRACE("format %#x, %u x %u.\n", desc.Format, desc.Width, desc.Height);
1422
1423     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
1424     subtype.Data1 = desc.Format;
1425
1426     if (!(stride = mf_format_get_stride(&subtype, desc.Width, &is_yuv)))
1427         return MF_E_INVALIDMEDIATYPE;
1428
1429     if (!(object = calloc(1, sizeof(*object))))
1430         return E_OUTOFMEMORY;
1431
1432     object->IMFMediaBuffer_iface.lpVtbl = &d3d9_surface_1d_buffer_vtbl;
1433     object->IMF2DBuffer2_iface.lpVtbl = &d3d9_surface_buffer_vtbl;
1434     object->IMFGetService_iface.lpVtbl = &d3d9_surface_buffer_gs_vtbl;
1435     object->refcount = 1;
1436     InitializeCriticalSection(&object->cs);
1437     object->d3d9_surface.surface = (IDirect3DSurface9 *)surface;
1438     IUnknown_AddRef(surface);
1439
1440     MFGetPlaneSize(desc.Format, desc.Width, desc.Height, &object->_2d.plane_size);
1441     object->_2d.width = stride;
1442     object->_2d.height = desc.Height;
1443     object->max_length = object->_2d.plane_size;
1444     object->_2d.copy_image = get_2d_buffer_copy_func(desc.Format);
1445
1446     *buffer = &object->IMFMediaBuffer_iface;
1447
1448     return S_OK;
1449 }
1450
1451 static HRESULT create_dxgi_surface_buffer(IUnknown *surface, unsigned int sub_resource_idx,
1452         BOOL bottom_up, IMFMediaBuffer **buffer)
1453 {
1454     struct buffer *object;
1455     D3D11_TEXTURE2D_DESC desc;
1456     ID3D11Texture2D *texture;
1457     unsigned int stride;
1458     D3DFORMAT format;
1459     GUID subtype;
1460     BOOL is_yuv;
1461     HRESULT hr;
1462
1463     if (FAILED(hr = IUnknown_QueryInterface(surface, &IID_ID3D11Texture2D, (void **)&texture)))
1464     {
1465         WARN("Failed to get texture interface, hr %#lx.\n", hr);
1466         return hr;
1467     }
1468
1469     ID3D11Texture2D_GetDesc(texture, &desc);
1470     TRACE("format %#x, %u x %u.\n", desc.Format, desc.Width, desc.Height);
1471
1472     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
1473     subtype.Data1 = format = MFMapDXGIFormatToDX9Format(desc.Format);
1474
1475     if (!(stride = mf_format_get_stride(&subtype, desc.Width, &is_yuv)))
1476     {
1477         ID3D11Texture2D_Release(texture);
1478         return MF_E_INVALIDMEDIATYPE;
1479     }
1480
1481     if (!(object = calloc(1, sizeof(*object))))
1482     {
1483         ID3D11Texture2D_Release(texture);
1484         return E_OUTOFMEMORY;
1485     }
1486
1487     object->IMFMediaBuffer_iface.lpVtbl = &dxgi_surface_1d_buffer_vtbl;
1488     object->IMF2DBuffer2_iface.lpVtbl = &dxgi_surface_buffer_vtbl;
1489     object->IMFDXGIBuffer_iface.lpVtbl = &dxgi_buffer_vtbl;
1490     object->refcount = 1;
1491     InitializeCriticalSection(&object->cs);
1492     object->dxgi_surface.texture = texture;
1493     object->dxgi_surface.sub_resource_idx = sub_resource_idx;
1494
1495     MFGetPlaneSize(format, desc.Width, desc.Height, &object->_2d.plane_size);
1496     object->_2d.width = stride;
1497     object->_2d.height = desc.Height;
1498     object->max_length = object->_2d.plane_size;
1499     object->_2d.copy_image = get_2d_buffer_copy_func(format);
1500
1501     if (FAILED(hr = init_attributes_object(&object->dxgi_surface.attributes, 0)))
1502     {
1503         IMFMediaBuffer_Release(&object->IMFMediaBuffer_iface);
1504         return hr;
1505     }
1506
1507     *buffer = &object->IMFMediaBuffer_iface;
1508
1509     return S_OK;
1510 }
1511
1512 /***********************************************************************
1513  *      MFCreateMemoryBuffer (mfplat.@)
1514  */
1515 HRESULT WINAPI MFCreateMemoryBuffer(DWORD max_length, IMFMediaBuffer **buffer)
1516 {
1517     TRACE("%lu, %p.\n", max_length, buffer);
1518
1519     return create_1d_buffer(max_length, MF_1_BYTE_ALIGNMENT, buffer);
1520 }
1521
1522 /***********************************************************************
1523  *      MFCreateAlignedMemoryBuffer (mfplat.@)
1524  */
1525 HRESULT WINAPI MFCreateAlignedMemoryBuffer(DWORD max_length, DWORD alignment, IMFMediaBuffer **buffer)
1526 {
1527     TRACE("%lu, %lu, %p.\n", max_length, alignment, buffer);
1528
1529     return create_1d_buffer(max_length, alignment, buffer);
1530 }
1531
1532 /***********************************************************************
1533  *      MFCreate2DMediaBuffer (mfplat.@)
1534  */
1535 HRESULT WINAPI MFCreate2DMediaBuffer(DWORD width, DWORD height, DWORD fourcc, BOOL bottom_up, IMFMediaBuffer **buffer)
1536 {
1537     TRACE("%lu, %lu, %s, %d, %p.\n", width, height, debugstr_fourcc(fourcc), bottom_up, buffer);
1538
1539     return create_2d_buffer(width, height, fourcc, bottom_up, buffer);
1540 }
1541
1542 /***********************************************************************
1543  *      MFCreateDXSurfaceBuffer (mfplat.@)
1544  */
1545 HRESULT WINAPI MFCreateDXSurfaceBuffer(REFIID riid, IUnknown *surface, BOOL bottom_up, IMFMediaBuffer **buffer)
1546 {
1547     TRACE("%s, %p, %d, %p.\n", debugstr_guid(riid), surface, bottom_up, buffer);
1548
1549     if (!IsEqualIID(riid, &IID_IDirect3DSurface9))
1550         return E_INVALIDARG;
1551
1552     return create_d3d9_surface_buffer(surface, bottom_up, buffer);
1553 }
1554
1555 /***********************************************************************
1556  *      MFCreateDXGISurfaceBuffer (mfplat.@)
1557  */
1558 HRESULT WINAPI MFCreateDXGISurfaceBuffer(REFIID riid, IUnknown *surface, UINT subresource, BOOL bottom_up,
1559         IMFMediaBuffer **buffer)
1560 {
1561     TRACE("%s, %p, %u, %d, %p.\n", debugstr_guid(riid), surface, subresource, bottom_up, buffer);
1562
1563     if (!IsEqualIID(riid, &IID_ID3D11Texture2D))
1564         return E_INVALIDARG;
1565
1566     return create_dxgi_surface_buffer(surface, subresource, bottom_up, buffer);
1567 }
1568
1569 static unsigned int buffer_get_aligned_length(unsigned int length, unsigned int alignment)
1570 {
1571     length = (length + alignment) / alignment;
1572     length *= alignment;
1573
1574     return length;
1575 }
1576
1577 HRESULT WINAPI MFCreateMediaBufferFromMediaType(IMFMediaType *media_type, LONGLONG duration, DWORD min_length,
1578         DWORD alignment, IMFMediaBuffer **buffer)
1579 {
1580     UINT32 length = 0, block_alignment;
1581     LONGLONG avg_length;
1582     HRESULT hr;
1583     GUID major;
1584
1585     TRACE("%p, %s, %lu, %lu, %p.\n", media_type, debugstr_time(duration), min_length, alignment, buffer);
1586
1587     if (!media_type)
1588         return E_INVALIDARG;
1589
1590     if (FAILED(hr = IMFMediaType_GetMajorType(media_type, &major)))
1591         return hr;
1592
1593     if (IsEqualGUID(&major, &MFMediaType_Audio))
1594     {
1595         block_alignment = 0;
1596         if (FAILED(IMFMediaType_GetUINT32(media_type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
1597             WARN("Block alignment was not specified.\n");
1598
1599         alignment = max(16, alignment);
1600
1601         if (block_alignment)
1602         {
1603             avg_length = 0;
1604
1605             if (duration)
1606             {
1607                 length = 0;
1608                 if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, &length)))
1609                 {
1610                     /* 100 ns -> 1 s */
1611                     avg_length = length * duration / (10 * 1000 * 1000);
1612                 }
1613             }
1614
1615             length = buffer_get_aligned_length(avg_length + 1, alignment);
1616             length = buffer_get_aligned_length(length, block_alignment);
1617         }
1618         else
1619             length = 0;
1620
1621         length = max(length, min_length);
1622
1623         return create_1d_buffer(length, alignment - 1, buffer);
1624     }
1625     else
1626         FIXME("Major type %s is not supported.\n", debugstr_guid(&major));
1627
1628     return E_NOTIMPL;
1629 }