dlls/mf/copier.c

   1 /*
   2  * Copyright 2020 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include "mfapi.h"
  22 #include "mfidl.h"
  23 #include "mf_private.h"
  24
  25 #include "wine/debug.h"
  26 #include "wine/heap.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  29
  30 enum sample_copier_flags
  31 {
  32     SAMPLE_COPIER_INPUT_TYPE_SET = 0x1,
  33     SAMPLE_COPIER_OUTPUT_TYPE_SET = 0x2
  34 };
  35
  36 struct sample_copier
  37 {
  38     IMFTransform IMFTransform_iface;
  39     LONG refcount;
  40
  41     IMFAttributes *attributes;
  42     IMFMediaType *buffer_type;
  43     DWORD buffer_size;
  44     IMFSample *sample;
  45     DWORD flags;
  46     CRITICAL_SECTION cs;
  47 };
  48
  49 static struct sample_copier *impl_from_IMFTransform(IMFTransform *iface)
  50 {
  51     return CONTAINING_RECORD(iface, struct sample_copier, IMFTransform_iface);
  52 }
  53
  54 static HRESULT WINAPI sample_copier_transform_QueryInterface(IMFTransform *iface, REFIID riid, void **obj)
  55 {
  56     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  57
  58     if (IsEqualIID(riid, &IID_IMFTransform) ||
  59             IsEqualIID(riid, &IID_IUnknown))
  60     {
  61         *obj = iface;
  62         IMFTransform_AddRef(iface);
  63         return S_OK;
  64     }
  65
  66     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
  67     *obj = NULL;
  68     return E_NOINTERFACE;
  69 }
  70
  71 static ULONG WINAPI sample_copier_transform_AddRef(IMFTransform *iface)
  72 {
  73     struct sample_copier *transform = impl_from_IMFTransform(iface);
  74     ULONG refcount = InterlockedIncrement(&transform->refcount);
  75
  76     TRACE("%p, refcount %u.\n", iface, refcount);
  77
  78     return refcount;
  79 }
  80
  81 static ULONG WINAPI sample_copier_transform_Release(IMFTransform *iface)
  82 {
  83     struct sample_copier *transform = impl_from_IMFTransform(iface);
  84     ULONG refcount = InterlockedDecrement(&transform->refcount);
  85
  86     TRACE("%p, refcount %u.\n", iface, refcount);
  87
  88     if (!refcount)
  89     {
  90         if (transform->attributes)
  91             IMFAttributes_Release(transform->attributes);
  92         if (transform->buffer_type)
  93             IMFMediaType_Release(transform->buffer_type);
  94         DeleteCriticalSection(&transform->cs);
  95         heap_free(transform);
  96     }
  97
  98     return refcount;
  99 }
 100
 101 static HRESULT WINAPI sample_copier_transform_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum,
 102         DWORD *input_maximum, DWORD *output_minimum, DWORD *output_maximum)
 103 {
 104     TRACE("%p, %p, %p, %p, %p.\n", iface, input_minimum, input_maximum, output_minimum, output_maximum);
 105
 106     *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1;
 107
 108     return S_OK;
 109 }
 110
 111 static HRESULT WINAPI sample_copier_transform_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs)
 112 {
 113     TRACE("%p, %p, %p.\n", iface, inputs, outputs);
 114
 115     *inputs = 1;
 116     *outputs = 1;
 117
 118     return S_OK;
 119 }
 120
 121 static HRESULT WINAPI sample_copier_transform_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs,
 122         DWORD output_size, DWORD *outputs)
 123 {
 124     TRACE("%p, %u, %p, %u, %p.\n", iface, input_size, inputs, output_size, outputs);
 125
 126     return E_NOTIMPL;
 127 }
 128
 129 static HRESULT WINAPI sample_copier_transform_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info)
 130 {
 131     struct sample_copier *transform = impl_from_IMFTransform(iface);
 132
 133     TRACE("%p, %u, %p.\n", iface, id, info);
 134
 135     memset(info, 0, sizeof(*info));
 136
 137     EnterCriticalSection(&transform->cs);
 138     info->cbSize = transform->buffer_size;
 139     LeaveCriticalSection(&transform->cs);
 140
 141     return S_OK;
 142 }
 143
 144 static HRESULT WINAPI sample_copier_transform_GetOutputStreamInfo(IMFTransform *iface, DWORD id,
 145         MFT_OUTPUT_STREAM_INFO *info)
 146 {
 147     struct sample_copier *transform = impl_from_IMFTransform(iface);
 148
 149     TRACE("%p, %u, %p.\n", iface, id, info);
 150
 151     memset(info, 0, sizeof(*info));
 152
 153     EnterCriticalSection(&transform->cs);
 154     info->cbSize = transform->buffer_size;
 155     LeaveCriticalSection(&transform->cs);
 156
 157     return S_OK;
 158 }
 159
 160 static HRESULT WINAPI sample_copier_transform_GetAttributes(IMFTransform *iface, IMFAttributes **attributes)
 161 {
 162     struct sample_copier *transform = impl_from_IMFTransform(iface);
 163
 164     TRACE("%p, %p.\n", iface, attributes);
 165
 166     *attributes = transform->attributes;
 167     IMFAttributes_AddRef(*attributes);
 168
 169     return S_OK;
 170 }
 171
 172 static HRESULT WINAPI sample_copier_transform_GetInputStreamAttributes(IMFTransform *iface, DWORD id,
 173         IMFAttributes **attributes)
 174 {
 175     TRACE("%p, %u, %p.\n", iface, id, attributes);
 176
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI sample_copier_transform_GetOutputStreamAttributes(IMFTransform *iface, DWORD id,
 181         IMFAttributes **attributes)
 182 {
 183     TRACE("%p, %u, %p.\n", iface, id, attributes);
 184
 185     return E_NOTIMPL;
 186 }
 187
 188 static HRESULT WINAPI sample_copier_transform_DeleteInputStream(IMFTransform *iface, DWORD id)
 189 {
 190     TRACE("%p, %u.\n", iface, id);
 191
 192     return E_NOTIMPL;
 193 }
 194
 195 static HRESULT WINAPI sample_copier_transform_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids)
 196 {
 197     TRACE("%p, %u, %p.\n", iface, streams, ids);
 198
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI sample_copier_transform_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 203         IMFMediaType **type)
 204 {
 205     static const GUID *types[] = { &MFMediaType_Video, &MFMediaType_Audio };
 206     HRESULT hr;
 207
 208     TRACE("%p, %u, %u, %p.\n", iface, id, index, type);
 209
 210     if (id)
 211         return MF_E_INVALIDSTREAMNUMBER;
 212
 213     if (index > ARRAY_SIZE(types) - 1)
 214         return MF_E_NO_MORE_TYPES;
 215
 216     if (SUCCEEDED(hr = MFCreateMediaType(type)))
 217         hr = IMFMediaType_SetGUID(*type, &MF_MT_MAJOR_TYPE, types[index]);
 218
 219     return hr;
 220 }
 221
 222 static HRESULT WINAPI sample_copier_transform_GetOutputAvailableType(IMFTransform *iface, DWORD id, DWORD index,
 223         IMFMediaType **type)
 224 {
 225     struct sample_copier *transform = impl_from_IMFTransform(iface);
 226     IMFMediaType *cloned_type = NULL;
 227     HRESULT hr = S_OK;
 228
 229     TRACE("%p, %u, %u, %p.\n", iface, id, index, type);
 230
 231     EnterCriticalSection(&transform->cs);
 232     if (transform->buffer_type)
 233     {
 234         if (SUCCEEDED(hr = MFCreateMediaType(&cloned_type)))
 235             hr = IMFMediaType_CopyAllItems(transform->buffer_type, (IMFAttributes *)cloned_type);
 236     }
 237     else if (id)
 238         hr = MF_E_INVALIDSTREAMNUMBER;
 239     else
 240         hr = MF_E_NO_MORE_TYPES;
 241     LeaveCriticalSection(&transform->cs);
 242
 243     if (SUCCEEDED(hr))
 244         *type = cloned_type;
 245     else if (cloned_type)
 246         IMFMediaType_Release(cloned_type);
 247
 248     return hr;
 249 }
 250
 251 static HRESULT sample_copier_get_buffer_size(IMFMediaType *type, DWORD *size)
 252 {
 253     GUID major, subtype;
 254     UINT64 frame_size;
 255     HRESULT hr;
 256
 257     *size = 0;
 258
 259     if (FAILED(hr = IMFMediaType_GetMajorType(type, &major)))
 260         return hr;
 261
 262     if (IsEqualGUID(&major, &MFMediaType_Video))
 263     {
 264         if (SUCCEEDED(hr = IMFMediaType_GetGUID(type, &MF_MT_SUBTYPE, &subtype)))
 265         {
 266             if (SUCCEEDED(hr = IMFMediaType_GetUINT64(type, &MF_MT_FRAME_SIZE, &frame_size)))
 267             {
 268                 if (FAILED(hr = MFCalculateImageSize(&subtype, (UINT32)(frame_size >> 32), (UINT32)frame_size, size)))
 269                     WARN("Failed to get image size for video format %s.\n", debugstr_guid(&subtype));
 270             }
 271         }
 272     }
 273     else if (IsEqualGUID(&major, &MFMediaType_Audio))
 274     {
 275         FIXME("Audio formats are not handled.\n");
 276         hr = E_NOTIMPL;
 277     }
 278
 279     return hr;
 280 }
 281
 282 static HRESULT sample_copier_set_media_type(struct sample_copier *transform, BOOL input, DWORD id, IMFMediaType *type,
 283         DWORD flags)
 284 {
 285     DWORD buffer_size;
 286     HRESULT hr = S_OK;
 287
 288     if (id)
 289         return MF_E_INVALIDSTREAMNUMBER;
 290
 291     EnterCriticalSection(&transform->cs);
 292     if (type)
 293     {
 294         hr = sample_copier_get_buffer_size(type, &buffer_size);
 295         if (!(flags & MFT_SET_TYPE_TEST_ONLY) && SUCCEEDED(hr))
 296         {
 297             if (!transform->buffer_type)
 298                 hr = MFCreateMediaType(&transform->buffer_type);
 299             if (SUCCEEDED(hr))
 300                 hr = IMFMediaType_CopyAllItems(type, (IMFAttributes *)transform->buffer_type);
 301             if (SUCCEEDED(hr))
 302                 transform->buffer_size = buffer_size;
 303
 304             if (SUCCEEDED(hr))
 305             {
 306                 if (input)
 307                 {
 308                     transform->flags |= SAMPLE_COPIER_INPUT_TYPE_SET;
 309                     transform->flags &= ~SAMPLE_COPIER_OUTPUT_TYPE_SET;
 310                 }
 311                 else
 312                     transform->flags |= SAMPLE_COPIER_OUTPUT_TYPE_SET;
 313             }
 314         }
 315     }
 316     else if (transform->buffer_type)
 317     {
 318         IMFMediaType_Release(transform->buffer_type);
 319         transform->buffer_type = NULL;
 320     }
 321     LeaveCriticalSection(&transform->cs);
 322
 323     return hr;
 324 }
 325
 326 static HRESULT WINAPI sample_copier_transform_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 327 {
 328     struct sample_copier *transform = impl_from_IMFTransform(iface);
 329
 330     TRACE("%p, %u, %p, %#x.\n", iface, id, type, flags);
 331
 332     return sample_copier_set_media_type(transform, TRUE, id, type, flags);
 333 }
 334
 335 static HRESULT WINAPI sample_copier_transform_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags)
 336 {
 337     struct sample_copier *transform = impl_from_IMFTransform(iface);
 338
 339     TRACE("%p, %u, %p, %#x.\n", iface, id, type, flags);
 340
 341     return sample_copier_set_media_type(transform, FALSE, id, type, flags);
 342 }
 343
 344 static HRESULT sample_copier_get_current_type(struct sample_copier *transform, DWORD id, DWORD flags,
 345         IMFMediaType **ret)
 346 {
 347     IMFMediaType *cloned_type = NULL;
 348     HRESULT hr;
 349
 350     if (id)
 351         return MF_E_INVALIDSTREAMNUMBER;
 352
 353     EnterCriticalSection(&transform->cs);
 354     if (transform->flags & flags)
 355     {
 356         if (SUCCEEDED(hr = MFCreateMediaType(&cloned_type)))
 357             hr = IMFMediaType_CopyAllItems(transform->buffer_type, (IMFAttributes *)cloned_type);
 358     }
 359     else
 360         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 361     LeaveCriticalSection(&transform->cs);
 362
 363     if (SUCCEEDED(hr))
 364         *ret = cloned_type;
 365     else if (cloned_type)
 366         IMFMediaType_Release(cloned_type);
 367
 368     return hr;
 369 }
 370
 371 static HRESULT WINAPI sample_copier_transform_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 372 {
 373     struct sample_copier *transform = impl_from_IMFTransform(iface);
 374
 375     TRACE("%p, %u, %p.\n", iface, id, type);
 376
 377     return sample_copier_get_current_type(transform, id, SAMPLE_COPIER_INPUT_TYPE_SET, type);
 378 }
 379
 380 static HRESULT WINAPI sample_copier_transform_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type)
 381 {
 382     struct sample_copier *transform = impl_from_IMFTransform(iface);
 383
 384     TRACE("%p, %u, %p.\n", iface, id, type);
 385
 386     return sample_copier_get_current_type(transform, id, SAMPLE_COPIER_OUTPUT_TYPE_SET, type);
 387 }
 388
 389 static HRESULT WINAPI sample_copier_transform_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *flags)
 390 {
 391     struct sample_copier *transform = impl_from_IMFTransform(iface);
 392     HRESULT hr = S_OK;
 393
 394     TRACE("%p, %u, %p.\n", iface, id, flags);
 395
 396     if (id)
 397         return MF_E_INVALIDSTREAMNUMBER;
 398
 399     EnterCriticalSection(&transform->cs);
 400     if (!(transform->flags & SAMPLE_COPIER_INPUT_TYPE_SET))
 401         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 402     else
 403         *flags = transform->sample ? 0 : MFT_INPUT_STATUS_ACCEPT_DATA;
 404     LeaveCriticalSection(&transform->cs);
 405
 406     return hr;
 407 }
 408
 409 static HRESULT WINAPI sample_copier_transform_GetOutputStatus(IMFTransform *iface, DWORD *flags)
 410 {
 411     struct sample_copier *transform = impl_from_IMFTransform(iface);
 412     HRESULT hr = S_OK;
 413
 414     TRACE("%p, %p.\n", iface, flags);
 415
 416     EnterCriticalSection(&transform->cs);
 417     if (!(transform->flags & SAMPLE_COPIER_OUTPUT_TYPE_SET))
 418         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 419     else
 420         *flags = transform->sample ? MFT_OUTPUT_STATUS_SAMPLE_READY : 0;
 421     LeaveCriticalSection(&transform->cs);
 422
 423     return hr;
 424 }
 425
 426 static HRESULT WINAPI sample_copier_transform_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper)
 427 {
 428     TRACE("%p, %s, %s.\n", iface, debugstr_time(lower), debugstr_time(upper));
 429
 430     return E_NOTIMPL;
 431 }
 432
 433 static HRESULT WINAPI sample_copier_transform_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event)
 434 {
 435     FIXME("%p, %u, %p.\n", iface, id, event);
 436
 437     return E_NOTIMPL;
 438 }
 439
 440 static HRESULT WINAPI sample_copier_transform_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param)
 441 {
 442     struct sample_copier *transform = impl_from_IMFTransform(iface);
 443
 444     TRACE("%p, %#x, %p.\n", iface, message, (void *)param);
 445
 446     EnterCriticalSection(&transform->cs);
 447
 448     if (message == MFT_MESSAGE_COMMAND_FLUSH)
 449     {
 450         if (transform->sample)
 451         {
 452             IMFSample_Release(transform->sample);
 453             transform->sample = NULL;
 454         }
 455     }
 456
 457     LeaveCriticalSection(&transform->cs);
 458
 459     return S_OK;
 460 }
 461
 462 static HRESULT WINAPI sample_copier_transform_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags)
 463 {
 464     struct sample_copier *transform = impl_from_IMFTransform(iface);
 465     HRESULT hr = S_OK;
 466
 467     TRACE("%p, %u, %p, %#x.\n", iface, id, sample, flags);
 468
 469     if (id)
 470         return MF_E_INVALIDSTREAMNUMBER;
 471
 472     EnterCriticalSection(&transform->cs);
 473     if (!transform->buffer_type)
 474         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 475     else if (transform->sample)
 476         hr = MF_E_NOTACCEPTING;
 477     else
 478     {
 479         transform->sample = sample;
 480         IMFSample_AddRef(transform->sample);
 481     }
 482     LeaveCriticalSection(&transform->cs);
 483
 484     return hr;
 485 }
 486
 487 static HRESULT WINAPI sample_copier_transform_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count,
 488         MFT_OUTPUT_DATA_BUFFER *buffers, DWORD *status)
 489 {
 490     struct sample_copier *transform = impl_from_IMFTransform(iface);
 491     IMFMediaBuffer *buffer;
 492     DWORD sample_flags;
 493     HRESULT hr = S_OK;
 494     LONGLONG time;
 495
 496     TRACE("%p, %#x, %u, %p, %p.\n", iface, flags, count, buffers, status);
 497
 498     EnterCriticalSection(&transform->cs);
 499     if (!(transform->flags & SAMPLE_COPIER_OUTPUT_TYPE_SET))
 500         hr = MF_E_TRANSFORM_TYPE_NOT_SET;
 501     else if (!transform->sample)
 502         hr = MF_E_TRANSFORM_NEED_MORE_INPUT;
 503     else
 504     {
 505         IMFSample_CopyAllItems(transform->sample, (IMFAttributes *)buffers->pSample);
 506
 507         if (SUCCEEDED(IMFSample_GetSampleDuration(transform->sample, &time)))
 508             IMFSample_SetSampleDuration(buffers->pSample, time);
 509
 510         if (SUCCEEDED(IMFSample_GetSampleTime(transform->sample, &time)))
 511             IMFSample_SetSampleTime(buffers->pSample, time);
 512
 513         if (SUCCEEDED(IMFSample_GetSampleFlags(transform->sample, &sample_flags)))
 514             IMFSample_SetSampleFlags(buffers->pSample, sample_flags);
 515
 516         if (SUCCEEDED(IMFSample_ConvertToContiguousBuffer(transform->sample, NULL)))
 517         {
 518             if (SUCCEEDED(IMFSample_GetBufferByIndex(buffers->pSample, 0, &buffer)))
 519             {
 520                 if (FAILED(IMFSample_CopyToBuffer(transform->sample, buffer)))
 521                     hr = MF_E_UNEXPECTED;
 522                 IMFMediaBuffer_Release(buffer);
 523             }
 524         }
 525
 526         IMFSample_Release(transform->sample);
 527         transform->sample = NULL;
 528     }
 529     LeaveCriticalSection(&transform->cs);
 530
 531     return hr;
 532 }
 533
 534 static const IMFTransformVtbl sample_copier_transform_vtbl =
 535 {
 536     sample_copier_transform_QueryInterface,
 537     sample_copier_transform_AddRef,
 538     sample_copier_transform_Release,
 539     sample_copier_transform_GetStreamLimits,
 540     sample_copier_transform_GetStreamCount,
 541     sample_copier_transform_GetStreamIDs,
 542     sample_copier_transform_GetInputStreamInfo,
 543     sample_copier_transform_GetOutputStreamInfo,
 544     sample_copier_transform_GetAttributes,
 545     sample_copier_transform_GetInputStreamAttributes,
 546     sample_copier_transform_GetOutputStreamAttributes,
 547     sample_copier_transform_DeleteInputStream,
 548     sample_copier_transform_AddInputStreams,
 549     sample_copier_transform_GetInputAvailableType,
 550     sample_copier_transform_GetOutputAvailableType,
 551     sample_copier_transform_SetInputType,
 552     sample_copier_transform_SetOutputType,
 553     sample_copier_transform_GetInputCurrentType,
 554     sample_copier_transform_GetOutputCurrentType,
 555     sample_copier_transform_GetInputStatus,
 556     sample_copier_transform_GetOutputStatus,
 557     sample_copier_transform_SetOutputBounds,
 558     sample_copier_transform_ProcessEvent,
 559     sample_copier_transform_ProcessMessage,
 560     sample_copier_transform_ProcessInput,
 561     sample_copier_transform_ProcessOutput,
 562 };
 563
 564 BOOL mf_is_sample_copier_transform(IMFTransform *transform)
 565 {
 566     return transform->lpVtbl == &sample_copier_transform_vtbl;
 567 }
 568
 569 /***********************************************************************
 570  *      MFCreateSampleCopierMFT (mf.@)
 571  */
 572 HRESULT WINAPI MFCreateSampleCopierMFT(IMFTransform **transform)
 573 {
 574     struct sample_copier *object;
 575     HRESULT hr;
 576
 577     TRACE("%p.\n", transform);
 578
 579     object = heap_alloc_zero(sizeof(*object));
 580     if (!object)
 581         return E_OUTOFMEMORY;
 582
 583     object->IMFTransform_iface.lpVtbl = &sample_copier_transform_vtbl;
 584     object->refcount = 1;
 585     InitializeCriticalSection(&object->cs);
 586
 587     if (FAILED(hr = MFCreateAttributes(&object->attributes, 0)))
 588         goto failed;
 589
 590     IMFAttributes_SetUINT32(object->attributes, &MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE, 1);
 591
 592     *transform = &object->IMFTransform_iface;
 593
 594     return S_OK;
 595
 596 failed:
 597
 598     IMFTransform_Release(&object->IMFTransform_iface);
 599
 600     return hr;
 601 }