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