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         MF2DBuffer_LockFlags lock_flags;
  60         p_copy_image_func copy_image;
  61     } _2d;
  62     struct
  63     {
  64         IDirect3DSurface9 *surface;
  65         D3DLOCKED_RECT rect;
  66     } d3d9_surface;
  67     struct
  68     {
  69         ID3D11Texture2D *texture;
  70         unsigned int sub_resource_idx;
  71         ID3D11Texture2D *rb_texture;
  72         D3D11_MAPPED_SUBRESOURCE map_desc;
  73         struct attributes attributes;
  74     } dxgi_surface;
  75
  76     CRITICAL_SECTION cs;
  77 };
  78
  79 static void copy_image(const struct buffer *buffer, BYTE *dest, LONG dest_stride, const BYTE *src,
  80         LONG src_stride, DWORD width, DWORD lines)
  81 {
  82     MFCopyImage(dest, dest_stride, src, src_stride, width, lines);
  83
  84     if (buffer->_2d.copy_image)
  85     {
  86         dest += dest_stride * lines;
  87         src += src_stride * lines;
  88         buffer->_2d.copy_image(dest, dest_stride, src, src_stride, width, lines);
  89     }
  90 }
  91
  92 static void copy_image_nv12(BYTE *dest, LONG dest_stride, const BYTE *src, LONG src_stride, DWORD width, DWORD lines)
  93 {
  94     MFCopyImage(dest, dest_stride, src, src_stride, width, lines / 2);
  95 }
  96
  97 static void copy_image_imc1(BYTE *dest, LONG dest_stride, const BYTE *src, LONG src_stride, DWORD width, DWORD lines)
  98 {
  99     MFCopyImage(dest, dest_stride, src, src_stride, width / 2, lines);
 100 }
 101
 102 static void copy_image_imc2(BYTE *dest, LONG dest_stride, const BYTE *src, LONG src_stride, DWORD width, DWORD lines)
 103 {
 104     MFCopyImage(dest, dest_stride / 2, src, src_stride / 2, width / 2, lines);
 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     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 605     BYTE *src_scanline0, *src_buffer_start;
 606     DWORD src_length;
 607     LONG src_pitch;
 608     HRESULT hr;
 609
 610     TRACE("%p, %p, %lu.\n", iface, dest_buffer, dest_length);
 611
 612     if (dest_length < buffer->_2d.plane_size)
 613         return E_INVALIDARG;
 614
 615     hr = IMF2DBuffer2_Lock2DSize(iface, MF2DBuffer_LockFlags_Read, &src_scanline0, &src_pitch, &src_buffer_start, &src_length);
 616
 617     if (SUCCEEDED(hr))
 618     {
 619         copy_image(buffer, dest_buffer, buffer->_2d.width, src_scanline0, src_pitch, buffer->_2d.width, buffer->_2d.height);
 620
 621         if (FAILED(IMF2DBuffer2_Unlock2D(iface)))
 622             WARN("Couldn't unlock source buffer %p, hr %#lx.\n", iface, hr);
 623     }
 624
 625     return S_OK;
 626 }
 627
 628 static HRESULT WINAPI memory_2d_buffer_ContiguousCopyFrom(IMF2DBuffer2 *iface, const BYTE *src_buffer, DWORD src_length)
 629 {
 630     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 631     BYTE *dst_scanline0, *dst_buffer_start;
 632     DWORD dst_length;
 633     LONG dst_pitch;
 634     HRESULT hr;
 635
 636     TRACE("%p, %p, %lu.\n", iface, src_buffer, src_length);
 637
 638     if (src_length < buffer->_2d.plane_size)
 639         return E_INVALIDARG;
 640
 641     hr = IMF2DBuffer2_Lock2DSize(iface, MF2DBuffer_LockFlags_Write, &dst_scanline0, &dst_pitch, &dst_buffer_start, &dst_length);
 642
 643     if (SUCCEEDED(hr))
 644     {
 645         copy_image(buffer, dst_scanline0, dst_pitch, src_buffer, buffer->_2d.width, buffer->_2d.width, buffer->_2d.height);
 646
 647         if (FAILED(IMF2DBuffer2_Unlock2D(iface)))
 648             WARN("Couldn't unlock destination buffer %p, hr %#lx.\n", iface, hr);
 649     }
 650
 651     return hr;
 652 }
 653
 654 static HRESULT WINAPI memory_2d_buffer_Lock2DSize(IMF2DBuffer2 *iface, MF2DBuffer_LockFlags flags, BYTE **scanline0,
 655         LONG *pitch, BYTE **buffer_start, DWORD *buffer_length)
 656 {
 657     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 658     HRESULT hr;
 659
 660     TRACE("%p, %#x, %p, %p, %p, %p.\n", iface, flags, scanline0, pitch, buffer_start, buffer_length);
 661
 662     if (!scanline0 || !pitch || !buffer_start || !buffer_length)
 663         return E_POINTER;
 664
 665     EnterCriticalSection(&buffer->cs);
 666
 667     hr = memory_2d_buffer_lock(buffer, scanline0, pitch, buffer_start, buffer_length);
 668
 669     LeaveCriticalSection(&buffer->cs);
 670
 671     return hr;
 672 }
 673
 674 static HRESULT WINAPI memory_2d_buffer_Copy2DTo(IMF2DBuffer2 *iface, IMF2DBuffer2 *dest_buffer)
 675 {
 676     FIXME("%p, %p.\n", iface, dest_buffer);
 677
 678     return E_NOTIMPL;
 679 }
 680
 681 static const IMF2DBuffer2Vtbl memory_2d_buffer_vtbl =
 682 {
 683     memory_2d_buffer_QueryInterface,
 684     memory_2d_buffer_AddRef,
 685     memory_2d_buffer_Release,
 686     memory_2d_buffer_Lock2D,
 687     memory_2d_buffer_Unlock2D,
 688     memory_2d_buffer_GetScanline0AndPitch,
 689     memory_2d_buffer_IsContiguousFormat,
 690     memory_2d_buffer_GetContiguousLength,
 691     memory_2d_buffer_ContiguousCopyTo,
 692     memory_2d_buffer_ContiguousCopyFrom,
 693     memory_2d_buffer_Lock2DSize,
 694     memory_2d_buffer_Copy2DTo,
 695 };
 696
 697 static HRESULT d3d9_surface_buffer_lock(struct buffer *buffer, MF2DBuffer_LockFlags flags, BYTE **scanline0,
 698         LONG *pitch, BYTE **buffer_start, DWORD *buffer_length)
 699 {
 700     HRESULT hr = S_OK;
 701
 702     if (buffer->_2d.linear_buffer)
 703         hr = MF_E_UNEXPECTED;
 704     else if (!buffer->_2d.locks)
 705         hr = IDirect3DSurface9_LockRect(buffer->d3d9_surface.surface, &buffer->d3d9_surface.rect, NULL, 0);
 706     else if (buffer->_2d.lock_flags == MF2DBuffer_LockFlags_Write && flags != MF2DBuffer_LockFlags_Write)
 707         hr = HRESULT_FROM_WIN32(ERROR_WAS_LOCKED);
 708
 709     if (SUCCEEDED(hr))
 710     {
 711         if (!buffer->_2d.locks)
 712             buffer->_2d.lock_flags = flags;
 713         buffer->_2d.locks++;
 714         *scanline0 = buffer->d3d9_surface.rect.pBits;
 715         *pitch = buffer->d3d9_surface.rect.Pitch;
 716         if (buffer_start)
 717             *buffer_start = *scanline0;
 718         if (buffer_length)
 719             *buffer_length = buffer->d3d9_surface.rect.Pitch * buffer->_2d.height;
 720     }
 721
 722     return hr;
 723 }
 724
 725 static HRESULT WINAPI d3d9_surface_buffer_Lock2D(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
 726 {
 727     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 728     HRESULT hr;
 729
 730     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
 731
 732     if (!scanline0 || !pitch)
 733         return E_POINTER;
 734
 735     EnterCriticalSection(&buffer->cs);
 736
 737     hr = d3d9_surface_buffer_lock(buffer, MF2DBuffer_LockFlags_ReadWrite, scanline0, pitch, NULL, NULL);
 738
 739     LeaveCriticalSection(&buffer->cs);
 740
 741     return hr;
 742 }
 743
 744 static HRESULT WINAPI d3d9_surface_buffer_Unlock2D(IMF2DBuffer2 *iface)
 745 {
 746     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 747     HRESULT hr = S_OK;
 748
 749     TRACE("%p.\n", iface);
 750
 751     EnterCriticalSection(&buffer->cs);
 752
 753     if (buffer->_2d.locks)
 754     {
 755         if (!--buffer->_2d.locks)
 756         {
 757             IDirect3DSurface9_UnlockRect(buffer->d3d9_surface.surface);
 758             memset(&buffer->d3d9_surface.rect, 0, sizeof(buffer->d3d9_surface.rect));
 759             buffer->_2d.lock_flags = 0;
 760         }
 761     }
 762     else
 763         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
 764
 765     LeaveCriticalSection(&buffer->cs);
 766
 767     return hr;
 768 }
 769
 770 static HRESULT WINAPI d3d9_surface_buffer_GetScanline0AndPitch(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
 771 {
 772     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 773     HRESULT hr = S_OK;
 774
 775     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
 776
 777     if (!scanline0 || !pitch)
 778         return E_POINTER;
 779
 780     EnterCriticalSection(&buffer->cs);
 781
 782     if (!buffer->_2d.locks)
 783     {
 784         *scanline0 = NULL;
 785         *pitch = 0;
 786         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
 787     }
 788     else
 789     {
 790         *scanline0 = buffer->d3d9_surface.rect.pBits;
 791         *pitch = buffer->d3d9_surface.rect.Pitch;
 792     }
 793
 794     LeaveCriticalSection(&buffer->cs);
 795
 796     return hr;
 797 }
 798
 799 static HRESULT WINAPI d3d9_surface_buffer_Lock2DSize(IMF2DBuffer2 *iface, MF2DBuffer_LockFlags flags, BYTE **scanline0,
 800         LONG *pitch, BYTE **buffer_start, DWORD *buffer_length)
 801 {
 802     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
 803     HRESULT hr;
 804
 805     TRACE("%p, %#x, %p, %p, %p, %p.\n", iface, flags, scanline0, pitch, buffer_start, buffer_length);
 806
 807     if (!scanline0 || !pitch || !buffer_start || !buffer_length)
 808         return E_POINTER;
 809
 810     EnterCriticalSection(&buffer->cs);
 811
 812     hr = d3d9_surface_buffer_lock(buffer, flags, scanline0, pitch, buffer_start, buffer_length);
 813
 814     LeaveCriticalSection(&buffer->cs);
 815
 816     return hr;
 817 }
 818
 819 static const IMF2DBuffer2Vtbl d3d9_surface_buffer_vtbl =
 820 {
 821     memory_2d_buffer_QueryInterface,
 822     memory_2d_buffer_AddRef,
 823     memory_2d_buffer_Release,
 824     d3d9_surface_buffer_Lock2D,
 825     d3d9_surface_buffer_Unlock2D,
 826     d3d9_surface_buffer_GetScanline0AndPitch,
 827     memory_2d_buffer_IsContiguousFormat,
 828     memory_2d_buffer_GetContiguousLength,
 829     memory_2d_buffer_ContiguousCopyTo,
 830     memory_2d_buffer_ContiguousCopyFrom,
 831     d3d9_surface_buffer_Lock2DSize,
 832     memory_2d_buffer_Copy2DTo,
 833 };
 834
 835 static HRESULT WINAPI memory_2d_buffer_gs_QueryInterface(IMFGetService *iface, REFIID riid, void **obj)
 836 {
 837     struct buffer *buffer = impl_from_IMFGetService(iface);
 838     return IMFMediaBuffer_QueryInterface(&buffer->IMFMediaBuffer_iface, riid, obj);
 839 }
 840
 841 static ULONG WINAPI memory_2d_buffer_gs_AddRef(IMFGetService *iface)
 842 {
 843     struct buffer *buffer = impl_from_IMFGetService(iface);
 844     return IMFMediaBuffer_AddRef(&buffer->IMFMediaBuffer_iface);
 845 }
 846
 847 static ULONG WINAPI memory_2d_buffer_gs_Release(IMFGetService *iface)
 848 {
 849     struct buffer *buffer = impl_from_IMFGetService(iface);
 850     return IMFMediaBuffer_Release(&buffer->IMFMediaBuffer_iface);
 851 }
 852
 853 static HRESULT WINAPI memory_2d_buffer_gs_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 854 {
 855     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 856
 857     return E_NOTIMPL;
 858 }
 859
 860 static const IMFGetServiceVtbl memory_2d_buffer_gs_vtbl =
 861 {
 862     memory_2d_buffer_gs_QueryInterface,
 863     memory_2d_buffer_gs_AddRef,
 864     memory_2d_buffer_gs_Release,
 865     memory_2d_buffer_gs_GetService,
 866 };
 867
 868 static HRESULT WINAPI d3d9_surface_buffer_gs_GetService(IMFGetService *iface, REFGUID service, REFIID riid, void **obj)
 869 {
 870     struct buffer *buffer = impl_from_IMFGetService(iface);
 871
 872     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(service), debugstr_guid(riid), obj);
 873
 874     if (IsEqualGUID(service, &MR_BUFFER_SERVICE))
 875     {
 876         return IDirect3DSurface9_QueryInterface(buffer->d3d9_surface.surface, riid, obj);
 877     }
 878
 879     return E_NOTIMPL;
 880 }
 881
 882 static const IMFGetServiceVtbl d3d9_surface_buffer_gs_vtbl =
 883 {
 884     memory_2d_buffer_gs_QueryInterface,
 885     memory_2d_buffer_gs_AddRef,
 886     memory_2d_buffer_gs_Release,
 887     d3d9_surface_buffer_gs_GetService,
 888 };
 889
 890 static HRESULT WINAPI dxgi_1d_2d_buffer_QueryInterface(IMFMediaBuffer *iface, REFIID riid, void **out)
 891 {
 892     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
 893
 894     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 895
 896     if (IsEqualIID(riid, &IID_IMFMediaBuffer) ||
 897             IsEqualIID(riid, &IID_IUnknown))
 898     {
 899         *out = &buffer->IMFMediaBuffer_iface;
 900     }
 901     else if (IsEqualIID(riid, &IID_IMF2DBuffer2) ||
 902             IsEqualIID(riid, &IID_IMF2DBuffer))
 903     {
 904         *out = &buffer->IMF2DBuffer2_iface;
 905     }
 906     else if (IsEqualIID(riid, &IID_IMFDXGIBuffer))
 907     {
 908         *out = &buffer->IMFDXGIBuffer_iface;
 909     }
 910     else
 911     {
 912         WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 913         *out = NULL;
 914         return E_NOINTERFACE;
 915     }
 916
 917     IUnknown_AddRef((IUnknown*)*out);
 918     return S_OK;
 919 }
 920
 921 static HRESULT dxgi_surface_buffer_create_readback_texture(struct buffer *buffer)
 922 {
 923     D3D11_TEXTURE2D_DESC texture_desc;
 924     ID3D11Device *device;
 925     HRESULT hr;
 926
 927     if (buffer->dxgi_surface.rb_texture)
 928         return S_OK;
 929
 930     ID3D11Texture2D_GetDevice(buffer->dxgi_surface.texture, &device);
 931
 932     ID3D11Texture2D_GetDesc(buffer->dxgi_surface.texture, &texture_desc);
 933     texture_desc.Usage = D3D11_USAGE_STAGING;
 934     texture_desc.BindFlags = 0;
 935     texture_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
 936     texture_desc.MiscFlags = 0;
 937     texture_desc.MipLevels = 1;
 938     if (FAILED(hr = ID3D11Device_CreateTexture2D(device, &texture_desc, NULL, &buffer->dxgi_surface.rb_texture)))
 939         WARN("Failed to create readback texture, hr %#lx.\n", hr);
 940
 941     ID3D11Device_Release(device);
 942
 943     return hr;
 944 }
 945
 946 static HRESULT dxgi_surface_buffer_map(struct buffer *buffer, MF2DBuffer_LockFlags flags)
 947 {
 948     ID3D11DeviceContext *immediate_context;
 949     ID3D11Device *device;
 950     HRESULT hr;
 951
 952     if (FAILED(hr = dxgi_surface_buffer_create_readback_texture(buffer)))
 953         return hr;
 954
 955     ID3D11Texture2D_GetDevice(buffer->dxgi_surface.texture, &device);
 956     ID3D11Device_GetImmediateContext(device, &immediate_context);
 957
 958     if (flags == MF2DBuffer_LockFlags_Read || flags == MF2DBuffer_LockFlags_ReadWrite)
 959     {
 960         ID3D11DeviceContext_CopySubresourceRegion(immediate_context, (ID3D11Resource *)buffer->dxgi_surface.rb_texture,
 961                 0, 0, 0, 0, (ID3D11Resource *)buffer->dxgi_surface.texture, buffer->dxgi_surface.sub_resource_idx, NULL);
 962     }
 963
 964     memset(&buffer->dxgi_surface.map_desc, 0, sizeof(buffer->dxgi_surface.map_desc));
 965     if (FAILED(hr = ID3D11DeviceContext_Map(immediate_context, (ID3D11Resource *)buffer->dxgi_surface.rb_texture,
 966             0, D3D11_MAP_READ_WRITE, 0, &buffer->dxgi_surface.map_desc)))
 967     {
 968         WARN("Failed to map readback texture, hr %#lx.\n", hr);
 969     }
 970
 971     ID3D11DeviceContext_Release(immediate_context);
 972     ID3D11Device_Release(device);
 973
 974     return hr;
 975 }
 976
 977 static void dxgi_surface_buffer_unmap(struct buffer *buffer, MF2DBuffer_LockFlags flags)
 978 {
 979     ID3D11DeviceContext *immediate_context;
 980     ID3D11Device *device;
 981
 982     ID3D11Texture2D_GetDevice(buffer->dxgi_surface.texture, &device);
 983     ID3D11Device_GetImmediateContext(device, &immediate_context);
 984     ID3D11DeviceContext_Unmap(immediate_context, (ID3D11Resource *)buffer->dxgi_surface.rb_texture, 0);
 985     memset(&buffer->dxgi_surface.map_desc, 0, sizeof(buffer->dxgi_surface.map_desc));
 986
 987     if (flags == MF2DBuffer_LockFlags_Write || flags == MF2DBuffer_LockFlags_ReadWrite)
 988     {
 989         ID3D11DeviceContext_CopySubresourceRegion(immediate_context, (ID3D11Resource *)buffer->dxgi_surface.texture,
 990                 buffer->dxgi_surface.sub_resource_idx, 0, 0, 0, (ID3D11Resource *)buffer->dxgi_surface.rb_texture, 0, NULL);
 991     }
 992
 993     ID3D11DeviceContext_Release(immediate_context);
 994     ID3D11Device_Release(device);
 995 }
 996
 997 static HRESULT WINAPI dxgi_surface_buffer_Lock(IMFMediaBuffer *iface, BYTE **data, DWORD *max_length,
 998         DWORD *current_length)
 999 {
1000     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
1001     HRESULT hr = S_OK;
1002
1003     TRACE("%p, %p, %p, %p.\n", iface, data, max_length, current_length);
1004
1005     if (!data)
1006         return E_POINTER;
1007
1008     EnterCriticalSection(&buffer->cs);
1009
1010     if (!buffer->_2d.linear_buffer && buffer->_2d.locks)
1011         hr = MF_E_INVALIDREQUEST;
1012     else if (!buffer->_2d.linear_buffer)
1013     {
1014         if (!(buffer->_2d.linear_buffer = malloc(buffer->_2d.plane_size)))
1015             hr = E_OUTOFMEMORY;
1016
1017         if (SUCCEEDED(hr))
1018         {
1019             hr = dxgi_surface_buffer_map(buffer, MF2DBuffer_LockFlags_ReadWrite);
1020             if (SUCCEEDED(hr))
1021             {
1022                 copy_image(buffer, buffer->_2d.linear_buffer, buffer->_2d.width, buffer->dxgi_surface.map_desc.pData,
1023                         buffer->dxgi_surface.map_desc.RowPitch, buffer->_2d.width, buffer->_2d.height);
1024             }
1025         }
1026     }
1027
1028     if (SUCCEEDED(hr))
1029     {
1030         ++buffer->_2d.locks;
1031         *data = buffer->_2d.linear_buffer;
1032         if (max_length)
1033             *max_length = buffer->_2d.plane_size;
1034         if (current_length)
1035             *current_length = buffer->_2d.plane_size;
1036     }
1037
1038     LeaveCriticalSection(&buffer->cs);
1039
1040     return hr;
1041 }
1042
1043 static HRESULT WINAPI dxgi_surface_buffer_Unlock(IMFMediaBuffer *iface)
1044 {
1045     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
1046     HRESULT hr = S_OK;
1047
1048     TRACE("%p.\n", iface);
1049
1050     EnterCriticalSection(&buffer->cs);
1051
1052     if (!buffer->_2d.linear_buffer)
1053         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
1054     else if (!--buffer->_2d.locks)
1055     {
1056         copy_image(buffer, buffer->dxgi_surface.map_desc.pData, buffer->dxgi_surface.map_desc.RowPitch,
1057                 buffer->_2d.linear_buffer, buffer->_2d.width, buffer->_2d.width, buffer->_2d.height);
1058         dxgi_surface_buffer_unmap(buffer, MF2DBuffer_LockFlags_ReadWrite);
1059
1060         free(buffer->_2d.linear_buffer);
1061         buffer->_2d.linear_buffer = NULL;
1062     }
1063
1064     LeaveCriticalSection(&buffer->cs);
1065
1066     return hr;
1067 }
1068
1069 static HRESULT WINAPI dxgi_surface_buffer_SetCurrentLength(IMFMediaBuffer *iface, DWORD current_length)
1070 {
1071     struct buffer *buffer = impl_from_IMFMediaBuffer(iface);
1072
1073     TRACE("%p, %lu.\n", iface, current_length);
1074
1075     buffer->current_length = current_length;
1076
1077     return S_OK;
1078 }
1079
1080 static HRESULT dxgi_surface_buffer_lock(struct buffer *buffer, MF2DBuffer_LockFlags flags,
1081         BYTE **scanline0, LONG *pitch, BYTE **buffer_start, DWORD *buffer_length)
1082 {
1083     HRESULT hr = S_OK;
1084
1085     if (buffer->_2d.linear_buffer)
1086         hr = MF_E_UNEXPECTED;
1087     else if (!buffer->_2d.locks)
1088         hr = dxgi_surface_buffer_map(buffer, flags);
1089     else if (buffer->_2d.lock_flags == MF2DBuffer_LockFlags_Write && flags != MF2DBuffer_LockFlags_Write)
1090         hr = HRESULT_FROM_WIN32(ERROR_WAS_LOCKED);
1091
1092     if (SUCCEEDED(hr))
1093     {
1094         if (!buffer->_2d.locks)
1095             buffer->_2d.lock_flags = flags;
1096         else
1097             buffer->_2d.lock_flags |= flags;
1098         buffer->_2d.locks++;
1099         *scanline0 = buffer->dxgi_surface.map_desc.pData;
1100         *pitch = buffer->dxgi_surface.map_desc.RowPitch;
1101         if (buffer_start)
1102             *buffer_start = *scanline0;
1103         if (buffer_length)
1104             *buffer_length = buffer->dxgi_surface.map_desc.DepthPitch;
1105     }
1106
1107     return hr;
1108 }
1109
1110 static HRESULT WINAPI dxgi_surface_buffer_Lock2D(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
1111 {
1112     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
1113     HRESULT hr;
1114
1115     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
1116
1117     if (!scanline0 || !pitch)
1118         return E_POINTER;
1119
1120     EnterCriticalSection(&buffer->cs);
1121
1122     hr = dxgi_surface_buffer_lock(buffer, MF2DBuffer_LockFlags_ReadWrite, scanline0, pitch, NULL, NULL);
1123
1124     LeaveCriticalSection(&buffer->cs);
1125
1126     return hr;
1127 }
1128
1129 static HRESULT WINAPI dxgi_surface_buffer_Unlock2D(IMF2DBuffer2 *iface)
1130 {
1131     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
1132     HRESULT hr = S_OK;
1133
1134     TRACE("%p.\n", iface);
1135
1136     EnterCriticalSection(&buffer->cs);
1137
1138     if (buffer->_2d.locks)
1139     {
1140         if (!--buffer->_2d.locks)
1141         {
1142             dxgi_surface_buffer_unmap(buffer, buffer->_2d.lock_flags);
1143             buffer->_2d.lock_flags = 0;
1144         }
1145     }
1146     else
1147         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
1148
1149     LeaveCriticalSection(&buffer->cs);
1150
1151     return hr;
1152 }
1153
1154 static HRESULT WINAPI dxgi_surface_buffer_GetScanline0AndPitch(IMF2DBuffer2 *iface, BYTE **scanline0, LONG *pitch)
1155 {
1156     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
1157     HRESULT hr = S_OK;
1158
1159     TRACE("%p, %p, %p.\n", iface, scanline0, pitch);
1160
1161     if (!scanline0 || !pitch)
1162         return E_POINTER;
1163
1164     EnterCriticalSection(&buffer->cs);
1165
1166     if (!buffer->_2d.locks)
1167     {
1168         *scanline0 = NULL;
1169         *pitch = 0;
1170         hr = HRESULT_FROM_WIN32(ERROR_WAS_UNLOCKED);
1171     }
1172     else
1173     {
1174         *scanline0 = buffer->dxgi_surface.map_desc.pData;
1175         *pitch = buffer->dxgi_surface.map_desc.RowPitch;
1176     }
1177
1178     LeaveCriticalSection(&buffer->cs);
1179
1180     return hr;
1181 }
1182
1183 static HRESULT WINAPI dxgi_surface_buffer_Lock2DSize(IMF2DBuffer2 *iface, MF2DBuffer_LockFlags flags,
1184         BYTE **scanline0, LONG *pitch, BYTE **buffer_start, DWORD *buffer_length)
1185 {
1186     struct buffer *buffer = impl_from_IMF2DBuffer2(iface);
1187     HRESULT hr;
1188
1189     TRACE("%p, %#x, %p, %p, %p, %p.\n", iface, flags, scanline0, pitch, buffer_start, buffer_length);
1190
1191     if (!scanline0 || !pitch || !buffer_start || !buffer_length)
1192         return E_POINTER;
1193
1194     EnterCriticalSection(&buffer->cs);
1195
1196     hr = dxgi_surface_buffer_lock(buffer, flags, scanline0, pitch, buffer_start, buffer_length);
1197
1198     LeaveCriticalSection(&buffer->cs);
1199
1200     return hr;
1201 }
1202
1203 static HRESULT WINAPI dxgi_buffer_QueryInterface(IMFDXGIBuffer *iface, REFIID riid, void **obj)
1204 {
1205     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1206     return IMFMediaBuffer_QueryInterface(&buffer->IMFMediaBuffer_iface, riid, obj);
1207 }
1208
1209 static ULONG WINAPI dxgi_buffer_AddRef(IMFDXGIBuffer *iface)
1210 {
1211     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1212     return IMFMediaBuffer_AddRef(&buffer->IMFMediaBuffer_iface);
1213 }
1214
1215 static ULONG WINAPI dxgi_buffer_Release(IMFDXGIBuffer *iface)
1216 {
1217     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1218     return IMFMediaBuffer_Release(&buffer->IMFMediaBuffer_iface);
1219 }
1220
1221 static HRESULT WINAPI dxgi_buffer_GetResource(IMFDXGIBuffer *iface, REFIID riid, void **obj)
1222 {
1223     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1224
1225     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
1226
1227     return ID3D11Texture2D_QueryInterface(buffer->dxgi_surface.texture, riid, obj);
1228 }
1229
1230 static HRESULT WINAPI dxgi_buffer_GetSubresourceIndex(IMFDXGIBuffer *iface, UINT *index)
1231 {
1232     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1233
1234     TRACE("%p, %p.\n", iface, index);
1235
1236     if (!index)
1237         return E_POINTER;
1238
1239     *index = buffer->dxgi_surface.sub_resource_idx;
1240
1241     return S_OK;
1242 }
1243
1244 static HRESULT WINAPI dxgi_buffer_GetUnknown(IMFDXGIBuffer *iface, REFIID guid, REFIID riid, void **object)
1245 {
1246     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1247
1248     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(guid), debugstr_guid(riid), object);
1249
1250     if (attributes_GetUnknown(&buffer->dxgi_surface.attributes, guid, riid, object) == MF_E_ATTRIBUTENOTFOUND)
1251         return MF_E_NOT_FOUND;
1252
1253     return S_OK;
1254 }
1255
1256 static HRESULT WINAPI dxgi_buffer_SetUnknown(IMFDXGIBuffer *iface, REFIID guid, IUnknown *data)
1257 {
1258     struct buffer *buffer = impl_from_IMFDXGIBuffer(iface);
1259     HRESULT hr = S_OK;
1260
1261     TRACE("%p, %s, %p.\n", iface, debugstr_guid(guid), data);
1262
1263     EnterCriticalSection(&buffer->dxgi_surface.attributes.cs);
1264     if (data)
1265     {
1266         if (SUCCEEDED(attributes_GetItem(&buffer->dxgi_surface.attributes, guid, NULL)))
1267             hr = HRESULT_FROM_WIN32(ERROR_OBJECT_ALREADY_EXISTS);
1268         else
1269             hr = attributes_SetUnknown(&buffer->dxgi_surface.attributes, guid, data);
1270     }
1271     else
1272     {
1273         attributes_DeleteItem(&buffer->dxgi_surface.attributes, guid);
1274     }
1275     LeaveCriticalSection(&buffer->dxgi_surface.attributes.cs);
1276
1277     return hr;
1278 }
1279
1280 static const IMFMediaBufferVtbl dxgi_surface_1d_buffer_vtbl =
1281 {
1282     dxgi_1d_2d_buffer_QueryInterface,
1283     memory_buffer_AddRef,
1284     memory_buffer_Release,
1285     dxgi_surface_buffer_Lock,
1286     dxgi_surface_buffer_Unlock,
1287     memory_buffer_GetCurrentLength,
1288     dxgi_surface_buffer_SetCurrentLength,
1289     memory_buffer_GetMaxLength,
1290 };
1291
1292 static const IMF2DBuffer2Vtbl dxgi_surface_buffer_vtbl =
1293 {
1294     memory_2d_buffer_QueryInterface,
1295     memory_2d_buffer_AddRef,
1296     memory_2d_buffer_Release,
1297     dxgi_surface_buffer_Lock2D,
1298     dxgi_surface_buffer_Unlock2D,
1299     dxgi_surface_buffer_GetScanline0AndPitch,
1300     memory_2d_buffer_IsContiguousFormat,
1301     memory_2d_buffer_GetContiguousLength,
1302     memory_2d_buffer_ContiguousCopyTo,
1303     memory_2d_buffer_ContiguousCopyFrom,
1304     dxgi_surface_buffer_Lock2DSize,
1305     memory_2d_buffer_Copy2DTo,
1306 };
1307
1308 static const IMFDXGIBufferVtbl dxgi_buffer_vtbl =
1309 {
1310     dxgi_buffer_QueryInterface,
1311     dxgi_buffer_AddRef,
1312     dxgi_buffer_Release,
1313     dxgi_buffer_GetResource,
1314     dxgi_buffer_GetSubresourceIndex,
1315     dxgi_buffer_GetUnknown,
1316     dxgi_buffer_SetUnknown,
1317 };
1318
1319 static HRESULT memory_buffer_init(struct buffer *buffer, DWORD max_length, DWORD alignment,
1320         const IMFMediaBufferVtbl *vtbl)
1321 {
1322     if (alignment < MF_16_BYTE_ALIGNMENT)
1323         alignment = MF_16_BYTE_ALIGNMENT;
1324     alignment++;
1325
1326     if (alignment & (alignment - 1))
1327     {
1328         alignment--;
1329         alignment |= alignment >> 1;
1330         alignment |= alignment >> 2;
1331         alignment |= alignment >> 4;
1332         alignment |= alignment >> 8;
1333         alignment |= alignment >> 16;
1334         alignment++;
1335     }
1336
1337     if (!(buffer->data = _aligned_malloc(max_length, alignment)))
1338         return E_OUTOFMEMORY;
1339     memset(buffer->data, 0, max_length);
1340
1341     buffer->IMFMediaBuffer_iface.lpVtbl = vtbl;
1342     buffer->refcount = 1;
1343     buffer->max_length = max_length;
1344     buffer->current_length = 0;
1345     InitializeCriticalSection(&buffer->cs);
1346
1347     return S_OK;
1348 }
1349
1350 static HRESULT create_1d_buffer(DWORD max_length, DWORD alignment, IMFMediaBuffer **buffer)
1351 {
1352     struct buffer *object;
1353     HRESULT hr;
1354
1355     if (!buffer)
1356         return E_POINTER;
1357
1358     *buffer = NULL;
1359
1360     if (!(object = calloc(1, sizeof(*object))))
1361         return E_OUTOFMEMORY;
1362
1363     hr = memory_buffer_init(object, max_length, alignment, &memory_1d_buffer_vtbl);
1364     if (FAILED(hr))
1365     {
1366         free(object);
1367         return hr;
1368     }
1369
1370     *buffer = &object->IMFMediaBuffer_iface;
1371
1372     return S_OK;
1373 }
1374
1375 static p_copy_image_func get_2d_buffer_copy_func(DWORD fourcc)
1376 {
1377     switch (fourcc)
1378     {
1379         case MAKEFOURCC('I','M','C','1'):
1380         case MAKEFOURCC('I','M','C','3'):
1381             return copy_image_imc1;
1382
1383         case MAKEFOURCC('I','M','C','2'):
1384         case MAKEFOURCC('I','M','C','4'):
1385         case MAKEFOURCC('N','V','1','1'):
1386         case MAKEFOURCC('Y','V','1','2'):
1387         case MAKEFOURCC('I','4','2','0'):
1388         case MAKEFOURCC('I','Y','U','V'):
1389             return copy_image_imc2;
1390
1391         case MAKEFOURCC('N','V','1','2'):
1392             return copy_image_nv12;
1393
1394         default:
1395             return NULL;
1396     }
1397 }
1398
1399 static HRESULT create_2d_buffer(DWORD width, DWORD height, DWORD fourcc, BOOL bottom_up, IMFMediaBuffer **buffer)
1400 {
1401     unsigned int stride, max_length;
1402     unsigned int row_alignment;
1403     struct buffer *object;
1404     DWORD plane_size;
1405     GUID subtype;
1406     BOOL is_yuv;
1407     HRESULT hr;
1408     int pitch;
1409
1410     if (!buffer)
1411         return E_POINTER;
1412
1413     *buffer = NULL;
1414
1415     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
1416     subtype.Data1 = fourcc;
1417
1418     if (!(stride = mf_format_get_stride(&subtype, width, &is_yuv)))
1419         return MF_E_INVALIDMEDIATYPE;
1420
1421     if (is_yuv && bottom_up)
1422         return MF_E_INVALIDMEDIATYPE;
1423
1424     switch (fourcc)
1425     {
1426         case MAKEFOURCC('I','M','C','1'):
1427         case MAKEFOURCC('I','M','C','3'):
1428             plane_size = stride * height * 2;
1429             break;
1430         case MAKEFOURCC('I','M','C','2'):
1431         case MAKEFOURCC('I','M','C','4'):
1432         case MAKEFOURCC('N','V','1','1'):
1433         case MAKEFOURCC('Y','V','1','2'):
1434         case MAKEFOURCC('I','4','2','0'):
1435         case MAKEFOURCC('I','Y','U','V'):
1436             plane_size = stride * 3 / 2 * height;
1437             break;
1438         case MAKEFOURCC('N','V','1','2'):
1439             plane_size = stride * height * 3 / 2;
1440             break;
1441         default:
1442             plane_size = stride * height;
1443     }
1444
1445     if (!(object = calloc(1, sizeof(*object))))
1446         return E_OUTOFMEMORY;
1447
1448     switch (fourcc)
1449     {
1450         case MAKEFOURCC('I','M','C','1'):
1451         case MAKEFOURCC('I','M','C','2'):
1452         case MAKEFOURCC('I','M','C','3'):
1453         case MAKEFOURCC('I','M','C','4'):
1454         case MAKEFOURCC('Y','V','1','2'):
1455         case MAKEFOURCC('N','V','1','1'):
1456         case MAKEFOURCC('I','4','2','0'):
1457         case MAKEFOURCC('I','Y','U','V'):
1458             row_alignment = MF_128_BYTE_ALIGNMENT;
1459             break;
1460         default:
1461             row_alignment = MF_64_BYTE_ALIGNMENT;
1462     }
1463
1464     pitch = ALIGN_SIZE(stride, row_alignment);
1465
1466     switch (fourcc)
1467     {
1468         case MAKEFOURCC('I','M','C','1'):
1469         case MAKEFOURCC('I','M','C','3'):
1470             max_length = pitch * height * 2;
1471             break;
1472         case MAKEFOURCC('N','V','1','2'):
1473         case MAKEFOURCC('Y','V','1','2'):
1474         case MAKEFOURCC('I','M','C','2'):
1475         case MAKEFOURCC('I','M','C','4'):
1476         case MAKEFOURCC('N','V','1','1'):
1477         case MAKEFOURCC('I','4','2','0'):
1478         case MAKEFOURCC('I','Y','U','V'):
1479             max_length = pitch * height * 3 / 2;
1480             break;
1481         default:
1482             max_length = pitch * height;
1483     }
1484
1485     if (FAILED(hr = memory_buffer_init(object, max_length, row_alignment, &memory_1d_2d_buffer_vtbl)))
1486     {
1487         free(object);
1488         return hr;
1489     }
1490
1491     object->IMF2DBuffer2_iface.lpVtbl = &memory_2d_buffer_vtbl;
1492     object->IMFGetService_iface.lpVtbl = &memory_2d_buffer_gs_vtbl;
1493     object->_2d.plane_size = plane_size;
1494     object->_2d.width = stride;
1495     object->_2d.height = height;
1496     object->_2d.pitch = bottom_up ? -pitch : pitch;
1497     object->_2d.scanline0 = bottom_up ? object->data + pitch * (object->_2d.height - 1) : object->data;
1498     object->_2d.copy_image = get_2d_buffer_copy_func(fourcc);
1499
1500     *buffer = &object->IMFMediaBuffer_iface;
1501
1502     return S_OK;
1503 }
1504
1505 static HRESULT create_d3d9_surface_buffer(IUnknown *surface, BOOL bottom_up, IMFMediaBuffer **buffer)
1506 {
1507     struct buffer *object;
1508     D3DSURFACE_DESC desc;
1509     unsigned int stride;
1510     GUID subtype;
1511     BOOL is_yuv;
1512
1513     IDirect3DSurface9_GetDesc((IDirect3DSurface9 *)surface, &desc);
1514     TRACE("format %#x, %u x %u.\n", desc.Format, desc.Width, desc.Height);
1515
1516     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
1517     subtype.Data1 = desc.Format;
1518
1519     if (!(stride = mf_format_get_stride(&subtype, desc.Width, &is_yuv)))
1520         return MF_E_INVALIDMEDIATYPE;
1521
1522     if (!(object = calloc(1, sizeof(*object))))
1523         return E_OUTOFMEMORY;
1524
1525     object->IMFMediaBuffer_iface.lpVtbl = &d3d9_surface_1d_buffer_vtbl;
1526     object->IMF2DBuffer2_iface.lpVtbl = &d3d9_surface_buffer_vtbl;
1527     object->IMFGetService_iface.lpVtbl = &d3d9_surface_buffer_gs_vtbl;
1528     object->refcount = 1;
1529     InitializeCriticalSection(&object->cs);
1530     object->d3d9_surface.surface = (IDirect3DSurface9 *)surface;
1531     IUnknown_AddRef(surface);
1532
1533     MFGetPlaneSize(desc.Format, desc.Width, desc.Height, &object->_2d.plane_size);
1534     object->_2d.width = stride;
1535     object->_2d.height = desc.Height;
1536     object->max_length = object->_2d.plane_size;
1537     object->_2d.copy_image = get_2d_buffer_copy_func(desc.Format);
1538
1539     *buffer = &object->IMFMediaBuffer_iface;
1540
1541     return S_OK;
1542 }
1543
1544 static HRESULT create_dxgi_surface_buffer(IUnknown *surface, unsigned int sub_resource_idx,
1545         BOOL bottom_up, IMFMediaBuffer **buffer)
1546 {
1547     struct buffer *object;
1548     D3D11_TEXTURE2D_DESC desc;
1549     ID3D11Texture2D *texture;
1550     unsigned int stride;
1551     D3DFORMAT format;
1552     GUID subtype;
1553     BOOL is_yuv;
1554     HRESULT hr;
1555
1556     if (FAILED(hr = IUnknown_QueryInterface(surface, &IID_ID3D11Texture2D, (void **)&texture)))
1557     {
1558         WARN("Failed to get texture interface, hr %#lx.\n", hr);
1559         return hr;
1560     }
1561
1562     ID3D11Texture2D_GetDesc(texture, &desc);
1563     TRACE("format %#x, %u x %u.\n", desc.Format, desc.Width, desc.Height);
1564
1565     memcpy(&subtype, &MFVideoFormat_Base, sizeof(subtype));
1566     subtype.Data1 = format = MFMapDXGIFormatToDX9Format(desc.Format);
1567
1568     if (!(stride = mf_format_get_stride(&subtype, desc.Width, &is_yuv)))
1569     {
1570         ID3D11Texture2D_Release(texture);
1571         return MF_E_INVALIDMEDIATYPE;
1572     }
1573
1574     if (!(object = calloc(1, sizeof(*object))))
1575     {
1576         ID3D11Texture2D_Release(texture);
1577         return E_OUTOFMEMORY;
1578     }
1579
1580     object->IMFMediaBuffer_iface.lpVtbl = &dxgi_surface_1d_buffer_vtbl;
1581     object->IMF2DBuffer2_iface.lpVtbl = &dxgi_surface_buffer_vtbl;
1582     object->IMFDXGIBuffer_iface.lpVtbl = &dxgi_buffer_vtbl;
1583     object->refcount = 1;
1584     InitializeCriticalSection(&object->cs);
1585     object->dxgi_surface.texture = texture;
1586     object->dxgi_surface.sub_resource_idx = sub_resource_idx;
1587
1588     MFGetPlaneSize(format, desc.Width, desc.Height, &object->_2d.plane_size);
1589     object->_2d.width = stride;
1590     object->_2d.height = desc.Height;
1591     object->max_length = object->_2d.plane_size;
1592     object->_2d.copy_image = get_2d_buffer_copy_func(format);
1593
1594     if (FAILED(hr = init_attributes_object(&object->dxgi_surface.attributes, 0)))
1595     {
1596         IMFMediaBuffer_Release(&object->IMFMediaBuffer_iface);
1597         return hr;
1598     }
1599
1600     *buffer = &object->IMFMediaBuffer_iface;
1601
1602     return S_OK;
1603 }
1604
1605 /***********************************************************************
1606  *      MFCreateMemoryBuffer (mfplat.@)
1607  */
1608 HRESULT WINAPI MFCreateMemoryBuffer(DWORD max_length, IMFMediaBuffer **buffer)
1609 {
1610     TRACE("%lu, %p.\n", max_length, buffer);
1611
1612     return create_1d_buffer(max_length, MF_1_BYTE_ALIGNMENT, buffer);
1613 }
1614
1615 /***********************************************************************
1616  *      MFCreateAlignedMemoryBuffer (mfplat.@)
1617  */
1618 HRESULT WINAPI MFCreateAlignedMemoryBuffer(DWORD max_length, DWORD alignment, IMFMediaBuffer **buffer)
1619 {
1620     TRACE("%lu, %lu, %p.\n", max_length, alignment, buffer);
1621
1622     return create_1d_buffer(max_length, alignment, buffer);
1623 }
1624
1625 /***********************************************************************
1626  *      MFCreate2DMediaBuffer (mfplat.@)
1627  */
1628 HRESULT WINAPI MFCreate2DMediaBuffer(DWORD width, DWORD height, DWORD fourcc, BOOL bottom_up, IMFMediaBuffer **buffer)
1629 {
1630     TRACE("%lu, %lu, %s, %d, %p.\n", width, height, debugstr_fourcc(fourcc), bottom_up, buffer);
1631
1632     return create_2d_buffer(width, height, fourcc, bottom_up, buffer);
1633 }
1634
1635 /***********************************************************************
1636  *      MFCreateDXSurfaceBuffer (mfplat.@)
1637  */
1638 HRESULT WINAPI MFCreateDXSurfaceBuffer(REFIID riid, IUnknown *surface, BOOL bottom_up, IMFMediaBuffer **buffer)
1639 {
1640     TRACE("%s, %p, %d, %p.\n", debugstr_guid(riid), surface, bottom_up, buffer);
1641
1642     if (!IsEqualIID(riid, &IID_IDirect3DSurface9))
1643         return E_INVALIDARG;
1644
1645     return create_d3d9_surface_buffer(surface, bottom_up, buffer);
1646 }
1647
1648 /***********************************************************************
1649  *      MFCreateDXGISurfaceBuffer (mfplat.@)
1650  */
1651 HRESULT WINAPI MFCreateDXGISurfaceBuffer(REFIID riid, IUnknown *surface, UINT subresource, BOOL bottom_up,
1652         IMFMediaBuffer **buffer)
1653 {
1654     TRACE("%s, %p, %u, %d, %p.\n", debugstr_guid(riid), surface, subresource, bottom_up, buffer);
1655
1656     if (!IsEqualIID(riid, &IID_ID3D11Texture2D))
1657         return E_INVALIDARG;
1658
1659     return create_dxgi_surface_buffer(surface, subresource, bottom_up, buffer);
1660 }
1661
1662 static unsigned int buffer_get_aligned_length(unsigned int length, unsigned int alignment)
1663 {
1664     length = (length + alignment) / alignment;
1665     length *= alignment;
1666
1667     return length;
1668 }
1669
1670 HRESULT WINAPI MFCreateMediaBufferFromMediaType(IMFMediaType *media_type, LONGLONG duration, DWORD min_length,
1671         DWORD alignment, IMFMediaBuffer **buffer)
1672 {
1673     UINT32 length = 0, block_alignment;
1674     LONGLONG avg_length;
1675     HRESULT hr;
1676     GUID major;
1677
1678     TRACE("%p, %s, %lu, %lu, %p.\n", media_type, debugstr_time(duration), min_length, alignment, buffer);
1679
1680     if (!media_type)
1681         return E_INVALIDARG;
1682
1683     if (FAILED(hr = IMFMediaType_GetMajorType(media_type, &major)))
1684         return hr;
1685
1686     if (IsEqualGUID(&major, &MFMediaType_Audio))
1687     {
1688         block_alignment = 0;
1689         if (FAILED(IMFMediaType_GetUINT32(media_type, &MF_MT_AUDIO_BLOCK_ALIGNMENT, &block_alignment)))
1690             WARN("Block alignment was not specified.\n");
1691
1692         alignment = max(16, alignment);
1693
1694         if (block_alignment)
1695         {
1696             avg_length = 0;
1697
1698             if (duration)
1699             {
1700                 length = 0;
1701                 if (SUCCEEDED(IMFMediaType_GetUINT32(media_type, &MF_MT_AUDIO_AVG_BYTES_PER_SECOND, &length)))
1702                 {
1703                     /* 100 ns -> 1 s */
1704                     avg_length = length * duration / (10 * 1000 * 1000);
1705                 }
1706             }
1707
1708             length = buffer_get_aligned_length(avg_length + 1, alignment);
1709             length = buffer_get_aligned_length(length, block_alignment);
1710         }
1711         else
1712             length = 0;
1713
1714         length = max(length, min_length);
1715
1716         return create_1d_buffer(length, alignment - 1, buffer);
1717     }
1718     else
1719         FIXME("Major type %s is not supported.\n", debugstr_guid(&major));
1720
1721     return E_NOTIMPL;
1722 }